def test_rops(self):
"""Checking rigid distance pair score"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
name = self.get_input_file_name("input.pdb")
p0 = IMP.get_particles(m, IMP._create_particles_from_pdb(name, m))
p1 = IMP.get_particles(m, IMP._create_particles_from_pdb(
self.get_input_file_name("input.pdb"), m))
print(len(p0), "particles", name)
print(len(p1), "particles", name)
rb0 = IMP.core.RigidBody.setup_particle(IMP.Particle(m), p0)
rb1 = IMP.core.RigidBody.setup_particle(IMP.Particle(m), p1)
randt = IMP.algebra.Transformation3D(IMP.algebra.get_random_rotation_3d(), IMP.algebra.get_random_vector_in(
IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0, 0, 0), IMP.algebra.Vector3D(100, 100, 100))))
IMP.core.RigidBody(rb0).set_reference_frame(
IMP.algebra.ReferenceFrame3D(randt))
sdps = IMP.core.SphereDistancePairScore(IMP.core.Linear(0, 1))
tr = IMP.core.TableRefiner()
tr.add_particle(p0[0], p0)
tr.add_particle(p1[0], p1)
rdps = IMP.core.RigidBodyDistancePairScore(sdps, tr)
v = rdps.evaluate_index(m, (p0[0], p1[0]), None)
dm = 1000000
bp = None
for l0 in p0:
for l1 in p1:
d = sdps.evaluate_index(m, (l0, l1), None)
if d < dm:
print("found ", l0.get_name(), l1.get_name(), d)
dm = d
self.assertAlmostEqual(v, dm, delta=.1)
def test_rops(self):
"""Checking rigid distance pair score"""
IMP.set_log_level(IMP.VERBOSE)
m= IMP.Model()
name=self.get_input_file_name("input.pdb")
p0= IMP._create_particles_from_pdb(name, m)
p1= IMP._create_particles_from_pdb(self.get_input_file_name("input.pdb"), m)
print len(p0), "particles", name
print len(p1), "particles", name
rb0= IMP.core.RigidBody.setup_particle(IMP.Particle(m),p0)
rb1= IMP.core.RigidBody.setup_particle(IMP.Particle(m),p1)
randt=IMP.algebra.Transformation3D(IMP.algebra.get_random_rotation_3d(), IMP.algebra.get_random_vector_in(IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0,0,0), IMP.algebra.Vector3D(100,100,100))))
IMP.core.RigidBody(rb0).set_reference_frame(IMP.algebra.ReferenceFrame3D(randt))
sdps= IMP.core.SphereDistancePairScore(IMP.core.Linear(0,1))
tr= IMP.core.TableRefiner()
tr.add_particle(p0[0], p0)
tr.add_particle(p1[0], p1)
rdps= IMP.core.RigidBodyDistancePairScore(sdps, tr)
v= rdps.evaluate((p0[0], p1[0]), None)
dm= 1000000
bp=None
for l0 in p0:
for l1 in p1:
d= sdps.evaluate((l0, l1), None)
if d< dm:
print "found ", l0.get_name(), l1.get_name(), d
dm=d
self.assertAlmostEqual(v, dm, delta=.1)
def test_filters(self):
"""Test filters on excluded volume"""
m = IMP.Model()
m.set_log_level(IMP.SILENT)
print("pdb")
h0s = IMP.get_particles(m, IMP._create_particles_from_pdb(
self.get_input_file_name("1z5s_A.pdb"), m))
l0 = h0s[0:10]
rm = h0s[10:]
for r in rm:
m.remove_particle(r)
del h0s
del rm
print("ev")
# set the restraint
r = IMP.core.ExcludedVolumeRestraint(l0, 1, 0)
print("cpc")
cpc = IMP.container.ClosePairContainer(l0, 0, 0)
cr = IMP.container.PairsRestraint(IMP.core.SoftSpherePairScore(1), cpc)
dg = IMP.get_dependency_graph(m)
# IMP.show_graphviz(dg)
idx = IMP.get_vertex_index(dg)
ss = IMP.get_required_score_states(cr, [], dg, idx)
print("ss", ss)
self.assert_(len(ss) > 0)
crsf = IMP.core.RestraintsScoringFunction([cr])
crsf.set_has_required_score_states(True)
print(crsf.get_required_score_states())
print(r.evaluate(False))
m.set_log_level(IMP.VERBOSE)
print(cr.evaluate(False))
pp = cpc.get_particle_pairs()
print("pairs are", pp)
self.assertAlmostEqual(r.evaluate(False), cr.evaluate(False),
delta=.1)
def test_create_one_from_pdb(self):
"""Testing create_rigid_bodies"""
m = IMP.Model()
hs = IMP._create_particles_from_pdb(
self.get_input_file_name("input.pdb"), m)
print("done reading")
rb = IMP.core.RigidBody.setup_particle(IMP.Particle(m), hs)
rb.set_coordinates_are_optimized(True)
print("done setting up")
ls = hs
keypts = [ls[0], ls[-1], ls[len(ls) // 3], ls[len(ls) // 3 * 2]]
tr = IMP.algebra.Transformation3D(
IMP.algebra.get_random_rotation_3d(),
IMP.algebra.get_random_vector_in(
IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(500, 500,
500))))
restraints = []
for p in keypts:
mp = IMP.core.RigidMember(m, p)
ic = mp.get_internal_coordinates()
nic = tr.get_transformed(ic)
dt = IMP.core.DistanceToSingletonScore(IMP.core.Harmonic(0, 1),
nic)
restraints.append(IMP.core.SingletonRestraint(m, dt, rb))
cg = IMP.core.ConjugateGradients(m)
sf = IMP.core.RestraintsScoringFunction(restraints)
cg.set_scoring_function(sf)
cg.optimize(600)
ntr = rb.get_reference_frame().get_transformation_to()
print(ntr)
print(tr)
self.assertLess(
(ntr.get_translation() - tr.get_translation()).get_magnitude(),
2.2)
def test_global_min2(self):
"""Test that more involved graphs are fine"""
m= IMP.Model()
aps=[]
rbs=[]
for i in range(3):
ps= IMP._create_particles_from_pdb(self.get_input_file_name("small_protein.pdb"), m)
p= IMP.Particle(m)
p.set_name("protein"+str(i))
aps.extend(ps)
rb=IMP.core.RigidBody.setup_particle(p, ps)
rbs.append(rb)
cp= IMP.container.ClosePairContainer(IMP.container.ListSingletonContainer(aps), 1, 0)
r=IMP.container.PairsRestraint(IMP.core.DistancePairScore(IMP.core.HarmonicLowerBound(0,1)), cp)
m.add_restraint(r)
print "computing graph"
pst= IMP.domino.ParticleStatesTable()
for p in rbs:
pst.set_particle_states(p, NullStates())
g= IMP.domino.get_interaction_graph([m.get_root_restraint_set()],
pst)
w= IMP.display.PymolWriter(self.get_tmp_file_name("ig0.pym"))
for gg in IMP.domino.get_interaction_graph_geometry(g):
w.add_geometry(gg)
del w
print "done"
vs= g.get_vertices()
IMP.show_graphviz(g)
for v in vs:
print v
l= g.get_vertex_name(v)
print l.get_name()
self.assertIn(l, rbs)
self.assertEqual(len(g.get_out_neighbors(v)), 2)
g.show()
def test_create_one_from_pdb(self):
"""Testing create_rigid_bodies"""
m= IMP.Model()
hs= IMP._create_particles_from_pdb(self.get_input_file_name("input.pdb"), m)
print "done reading"
rb= IMP.core.RigidBody.setup_particle(IMP.Particle(m), hs)
rb.set_coordinates_are_optimized(True)
print "done setting up"
ls= hs
keypts= [ls[0], ls[-1], ls[len(ls)/3], ls[len(ls)/3*2]]
tr= IMP.algebra.Transformation3D(IMP.algebra.get_random_rotation_3d(),
IMP.algebra.get_random_vector_in(IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0,0,0), IMP.algebra.Vector3D(500, 500, 500))))
for p in keypts:
mp= IMP.core.RigidMember(p)
ic= mp.get_internal_coordinates()
nic= tr.get_transformed(ic)
dt= IMP.core.DistanceToSingletonScore(IMP.core.Harmonic(0,1), nic)
r= IMP.core.SingletonRestraint(dt, rb)
m.add_restraint(r)
cg= IMP.core.ConjugateGradients()
cg.set_model(m)
cg.optimize(600)
ntr= rb.get_reference_frame().get_transformation_to()
print ntr
print tr
self.assertLess((ntr.get_translation()- tr.get_translation()).get_magnitude(), 2.2)
def test_global_min3(self):
"""Test that showing interaction graphs is fine"""
m= IMP.Model()
IMP.set_log_level(IMP.SILENT)
ps= IMP._create_particles_from_pdb(self.get_input_file_name("small_protein.pdb"), m)
#print "radius is ", IMP.core.XYZR(IMP.atom.get_leaves(p)[0]).get_radius()
#exit(1)
#sp= IMP.atom.get_simplified_by_residue(p, 1)
cpf= IMP.core.QuadraticClosePairsFinder()
cpf.set_distance(0.0)
print len(ps), "leaves"
cp= cpf.get_close_pairs(ps)
for pr in cp:
r=IMP.core.PairRestraint(IMP.core.DistancePairScore(IMP.core.HarmonicLowerBound(0,1)), pr)
m.add_restraint(r)
r.set_name("pair")
print "computing graph"
pst= IMP.domino.ParticleStatesTable()
for p in ps:
pst.set_particle_states(p, NullStates())
g= IMP.domino.get_interaction_graph([m.get_root_restraint_set()],
pst)
w= IMP.display.PymolWriter(self.get_tmp_file_name("ig-large.pym"))
gs=IMP.domino.get_interaction_graph_geometry(g)
print "There are ", len(gs)
for gg in gs:
w.add_geometry(gg)
del w
def test_filters(self):
"""Test filters on excluded volume"""
m = IMP.Model()
m.set_log_level(IMP.SILENT)
print "pdb"
h0s=IMP._create_particles_from_pdb(self.get_input_file_name("1z5s_A.pdb"),
m)
l0= h0s[0:10]
rm= h0s[10:]
for r in rm:
m.remove_particle(r)
del h0s
del rm
print "ev"
#set the restraint
c0= IMP.container.ListSingletonContainer(l0)
r=IMP.core.ExcludedVolumeRestraint(l0, 1, 0)
print "cpc"
cpc= IMP.container.ClosePairContainer(l0, 0, 0)
cr= IMP.container.PairsRestraint(IMP.core.SoftSpherePairScore(1), cpc)
c1= IMP.container.ListSingletonContainer(l0)
dg= IMP.get_dependency_graph(m)
IMP.base.show_graphviz(dg)
idx= IMP.get_vertex_index(dg)
ss= IMP.get_required_score_states(cr, [], dg, idx)
print "ss", ss
crsf= cr.create_scoring_function()
print crsf.get_score_states()
print r.evaluate(False)
m.set_log_level(IMP.VERBOSE)
print cr.evaluate(False)
pp= cpc.get_particle_pairs()
print pp
self.assertAlmostEqual(r.evaluate(False), cr.evaluate(False),
delta=.1)
def test_global_min3(self):
"""Test that showing interaction graphs is fine"""
m = IMP.Model()
IMP.set_log_level(IMP.SILENT)
ps = IMP._create_particles_from_pdb(
self.get_input_file_name("small_protein.pdb"),
m)
# print "radius is ", IMP.core.XYZR(IMP.atom.get_leaves(p)[0]).get_radius()
# exit(1)
#sp= IMP.atom.get_simplified_by_residue(p, 1)
cpf = IMP.core.QuadraticClosePairsFinder()
cpf.set_distance(0.0)
print(len(ps), "leaves")
cp = cpf.get_close_pairs(m, ps)
rs = IMP.RestraintSet(m)
for pr in cp:
r = IMP.core.PairRestraint(m,
IMP.core.DistancePairScore(IMP.core.HarmonicLowerBound(0, 1)), pr)
rs.add_restraint(r)
r.set_name("pair")
print("computing graph")
pst = IMP.domino.ParticleStatesTable()
for p in ps:
pst.set_particle_states(m.get_particle(p), NullStates())
g = IMP.domino.get_interaction_graph([rs], pst)
#w = IMP.display.PymolWriter(self.get_tmp_file_name("ig-large.pym"))
gs = IMP.domino.get_interaction_graph_geometry(g)
print("There are ", len(gs))
def test_molecule(self):
m = IMP.Model()
name = self.get_input_file_name("input.pdb")
pdb = IMP._create_particles_from_pdb(name, m)
spheres = [IMP.core.XYZR(m, p).get_sphere() for p in pdb]
sps = IMP.algebra.get_connolly_surface(spheres, 5, 1.8)
sps_area = sum([s.get_area() for s in sps])
self.assertAlmostEqual(sps_area, 5478.68, delta=.2)
def test_molecule(self):
m = IMP.Model()
name = self.get_input_file_name("input.pdb")
pdb = IMP._create_particles_from_pdb(name, m)
spheres = [IMP.core.XYZR(m, p).get_sphere() for p in pdb]
sps = IMP.algebra.get_connolly_surface(spheres, 5, 1.8)
sps_area = sum([s.get_area() for s in sps])
self.assertAlmostEqual(sps_area, 5478.68, delta=.2)
def setUp(self):
IMP.test.TestCase.setUp(self)
#IMP.set_log_level(IMP.TERSE)
self.m = IMP.Model()
#read molecules
self.m1 = IMP._create_particles_from_pdb(self.get_input_file_name("1z5s_A.pdb"),
self.m)
self.m2 = IMP._create_particles_from_pdb(self.get_input_file_name("1z5s_C.pdb"),
self.m)
#create rigid bodies
self.rb0=IMP.core.RigidBody.setup_particle(IMP.Particle(self.m), self.m1)
self.rb0.set_coordinates_are_optimized(True)
self.rb1=IMP.core.RigidBody.setup_particle(IMP.Particle(self.m), self.m2)
self.rb1.set_coordinates_are_optimized(True)
#add restraints
self.h = IMP.core.HarmonicUpperBound(0,3.)
self.dr = IMP.core.DistanceRestraint(self.h,self.rb0, self.rb1)
self.m.add_restraint(self.dr)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.set_log_level(IMP.TERSE)
self.m = IMP.Model()
# read molecules
self.m1 = IMP._create_particles_from_pdb(
self.get_input_file_name("1z5s_A.pdb"), self.m)
self.m2 = IMP._create_particles_from_pdb(
self.get_input_file_name("1z5s_C.pdb"), self.m)
# create rigid bodies
self.rb0 = IMP.core.RigidBody.setup_particle(IMP.Particle(self.m),
self.m1)
self.rb0.set_coordinates_are_optimized(True)
self.rb1 = IMP.core.RigidBody.setup_particle(IMP.Particle(self.m),
self.m2)
self.rb1.set_coordinates_are_optimized(True)
# add restraints
self.h = IMP.core.HarmonicUpperBound(0, 3.)
self.dr = IMP.core.DistanceRestraint(self.m, self.h, self.rb0,
self.rb1)
self.sf = IMP.core.RestraintsScoringFunction([self.dr])
def test_docking_solutions(self):
"""Test nested rigid bodies"""
# load components
mdl = IMP.Model()
mhs = []
rbs = []
aps = []
for i in range(3):
fn = "small_protein.pdb"
ps = IMP._create_particles_from_pdb(
self.get_input_file_name(fn),
mdl)
aps.extend(ps)
p = IMP.Particle(mdl)
rb = IMP.core.RigidBody.setup_particle(p, ps)
mhs.append(rb)
mhs[-1].set_name("molecule" + str(i))
rbs.append(rb)
ts = []
bb = IMP.algebra.BoundingBox3D(
IMP.algebra.Vector3D(-10., -10., -10.),
IMP.algebra.Vector3D(10., 10., 10.))
for i in range(5):
ts.append(IMP.algebra.Transformation3D(
IMP.algebra.get_random_rotation_3d(),
IMP.algebra.get_random_vector_in(bb)))
# set nesting
for i in range(len(rbs) - 1):
rbs[0].add_member(rbs[i + 1])
# set ev
IMP.set_log_level(IMP.SILENT)
ls = IMP.container.ListSingletonContainer(mdl, aps)
sev = IMP.core.ExcludedVolumeRestraint(ls)
sev.evaluate(False)
# set states
pst = IMP.domino.ParticleStatesTable()
for i in range(1):
states = IMP.domino.NestedRigidBodyStates(ts)
pst.set_particle_states(rbs[i + 1], states)
id_trans = []
id_trans.append(rbs[0].get_reference_frame())
pst.set_particle_states(rbs[0], IMP.domino.RigidBodyStates(id_trans))
ds = IMP.domino.DominoSampler(mdl, pst)
ds.set_restraints([sev])
cg = ds.create_sample()
print(cg.get_number_of_configurations())
def test_docking_solutions(self):
"""Test nested rigid bodies"""
# load components
mdl = IMP.Model()
mhs = []
rbs = []
aps = []
for i in range(3):
fn = "small_protein.pdb"
ps = IMP._create_particles_from_pdb(self.get_input_file_name(fn),
mdl)
aps.extend(ps)
p = IMP.Particle(mdl)
rb = IMP.core.RigidBody.setup_particle(p, ps)
mhs.append(rb)
mhs[-1].set_name("molecule" + str(i))
rbs.append(rb)
ts = []
bb = IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(-10., -10., -10.),
IMP.algebra.Vector3D(10., 10., 10.))
for i in range(5):
ts.append(
IMP.algebra.Transformation3D(
IMP.algebra.get_random_rotation_3d(),
IMP.algebra.get_random_vector_in(bb)))
# set nesting
for i in range(len(rbs) - 1):
rbs[0].add_member(rbs[i + 1])
# set ev
IMP.set_log_level(IMP.SILENT)
ls = IMP.container.ListSingletonContainer(mdl, aps)
sev = IMP.core.ExcludedVolumeRestraint(ls)
sev.evaluate(False)
# set states
pst = IMP.domino.ParticleStatesTable()
for i in range(1):
states = IMP.domino.NestedRigidBodyStates(ts)
pst.set_particle_states(rbs[i + 1], states)
id_trans = []
id_trans.append(rbs[0].get_reference_frame())
pst.set_particle_states(rbs[0], IMP.domino.RigidBodyStates(id_trans))
ds = IMP.domino.DominoSampler(mdl, pst)
ds.set_restraints([sev])
cg = ds.create_sample()
print(cg.get_number_of_configurations())
def test_rops_against_one(self):
"""Checking rigid distance pair score against one"""
IMP.set_log_level(IMP.VERBOSE)
m= IMP.Model()
p0= IMP._create_particles_from_pdb(self.get_input_file_name("input.pdb"), m)
print len(p0), "particles"
p1= IMP.Particle(m)
randt=IMP.algebra.get_random_vector_in(IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0,0,0), IMP.algebra.Vector3D(100,100,100)))
IMP.core.XYZR.setup_particle(p1, IMP.algebra.Sphere3D(randt, 3))
rb=IMP.core.RigidBody.setup_particle(IMP.Particle(m), p0)
sdps= IMP.core.SphereDistancePairScore(IMP.core.Linear(0,1))
tr= IMP.core.TableRefiner();
tr.add_particle(p0[0], p0)
rdps= IMP.core.RigidBodyDistancePairScore(sdps, tr)
v= rdps.evaluate((p0[0], p1), None)
dm= 1000000
bp=None
for l0 in p0:
d= sdps.evaluate((l0, p1), None)
if d< dm:
dm=d
self.assertAlmostEqual(v, dm, delta=.1)
def test_global_min2(self):
"""Test that more involved graphs are fine"""
m = IMP.Model()
aps = []
rbs = []
for i in range(2):
ps = IMP._create_particles_from_pdb(
self.get_input_file_name("small_protein.pdb"), m)
p = IMP.Particle(m)
p.set_name("protein" + str(i))
aps.extend(ps)
rb = IMP.core.RigidBody.setup_particle(p, ps)
rbs.append(rb)
cp = IMP.container.ClosePairContainer(
IMP.container.ListSingletonContainer(m, aps), 1, 0)
r = IMP.container.PairsRestraint(
IMP.core.DistancePairScore(IMP.core.HarmonicLowerBound(0, 1)), cp)
rs = IMP.RestraintSet(m)
rs.add_restraint(r)
print("computing graph")
pst = IMP.domino.ParticleStatesTable()
for p in rbs:
pst.set_particle_states(p, NullStates())
g = IMP.domino.get_interaction_graph([rs], pst)
#w = IMP.display.PymolWriter(self.get_tmp_file_name("ig0.pym"))
# for gg in IMP.domino.get_interaction_graph_geometry(g):
# w.add_geometry(gg)
#del w
print("done")
vs = g.get_vertices()
# IMP.show_graphviz(g)
for v in vs:
print(v)
l = g.get_vertex_name(v)
print(l.get_name())
self.assertIn(l, rbs)
self.assertEqual(len(g.get_out_neighbors(v)), 1)
def test_rops_against_one(self):
"""Checking rigid distance pair score against one"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
p0 = IMP.get_particles(m, IMP._create_particles_from_pdb(
self.get_input_file_name("input.pdb"), m))
print(len(p0), "particles")
p1 = m.add_particle("p")
randt = IMP.algebra.get_random_vector_in(IMP.algebra.BoundingBox3D(
IMP.algebra.Vector3D(0, 0, 0), IMP.algebra.Vector3D(100, 100, 100)))
IMP.core.XYZR.setup_particle(m, p1, IMP.algebra.Sphere3D(randt, 3))
rb = IMP.core.RigidBody.setup_particle(IMP.Particle(m), p0)
sdps = IMP.core.SphereDistancePairScore(IMP.core.Linear(0, 1))
tr = IMP.core.TableRefiner()
tr.add_particle(p0[0], p0)
rdps = IMP.core.RigidBodyDistancePairScore(sdps, tr)
v = rdps.evaluate_index(m, (p0[0], p1), None)
dm = 1000000
bp = None
for l0 in p0:
d = sdps.evaluate_index(m, (l0, p1), None)
if d < dm:
dm = d
self.assertAlmostEqual(v, dm, delta=.1)
