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 setUp(self):
"""initialize IMP environment create particles"""
IMP.test.TestCase.setUp(self)
IMP.set_log_level(IMP.SILENT)
IMP.set_check_level(IMP.NONE)
# init IMP model ( the environment)
self.imp_model = IMP.Model()
self.particles = []
# - create a set of three particles in imp
npart = 3
self.rad_key = IMP.FloatKey("radius")
self.weight_key = IMP.FloatKey("weight")
for i, (x, y, z) in enumerate(((9.0, 9.0, 9.0),
(12.0, 3.0, 3.0),
(3.0, 12.0, 12.0))):
p = self.create_point_particle(self.imp_model, x, y, z)
p.add_attribute(self.rad_key, 1.0, False)
p.add_attribute(self.weight_key, 10.0)
p.add_attribute(IMP.IntKey("id"), i)
p.add_attribute(IMP.IntKey("protein"), 1)
self.particles.append(p)
self.particle_indexes = []
for i in range(npart):
self.particle_indexes.append(i)
print("initialization done ...")
def test_delete_model_accessor(self):
"Python Particles from vector accessors should survive model deletion"
IMP.set_log_level(IMP.MEMORY)
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("test model")
IMP.Particle(m)
# Now create new Python particle p from a C++ vector accessor
# (front(), back(), [], etc.)
# (not the Python IMP.Particle() constructor)
# These accessors call specific methods in the SWIG wrapper which
# are modified by typemaps in our interface.
print("getting particles")
ps = m.get_particle_indexes()
print("getting particle")
p = m.get_particle(ps[0])
del ps
# Python reference p plus C++ reference from m
self.assertEqual(p.get_ref_count(), 2)
print("deleting model")
del m
# Now only the Python reference p should survive
self.assertEqual(p.get_ref_count(), 1)
refcnt.assert_number(1)
print(p)
print("deleting p")
print(p.thisown)
del p
refcnt.assert_number(0)
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_set(self):
"""Testing ClassnamesConstraint"""
# write increment an int field
# call evaluate and check that it is incremented
IMP.set_log_level(IMP.VERBOSE)
print("start")
m = IMP.Model()
print("hi")
c = IMP.container.ListClassnameContainer(m)
cs = []
for i in range(0, 30):
t = self.create_FUNCTIONNAME(m)
if 'FUNCTIONNAME' == 'particle':
c.add(t.get_index())
else:
c.add([x.get_index() for x in t])
cs.append(t)
print("dl")
k = IMP.IntKey("thevalue")
f = ClassnameTestModifier(k)
print("apply")
s = IMP.container.ClassnamesConstraint(f, None, c)
print("add")
m.add_score_state(s)
m.update()
for p in cs:
self.assertTrue(FUNCTIONNAME_has_attribute(p, k))
print("done")
def _test_explicit(self, nm):
"""Testing default subset states with explicit equivalencies"""
m = IMP.Model()
ps = []
ns = 5
np = 4
for i in range(0, np):
ps.append(IMP.Particle(m))
pst = IMP.domino.ParticleStatesTable()
tps = TrivialParticleStates(ns)
pst.set_particle_states(ps[0], tps)
pst.set_particle_states(ps[1], tps)
for p in ps[2:]:
pst.set_particle_states(p, TrivialParticleStates(ns))
pft = IMP.domino.ExclusionSubsetFilterTable()
pft.add_pair((ps[0], ps[1]))
dsst = nm(pst, [pft])
lsc = IMP.domino.Subset(ps)
IMP.set_log_level(IMP.SILENT)
pss = IMP.domino.PackedAssignmentContainer()
dsst.load_assignments(lsc, pss)
ss = pss.get_assignments((0, pss.get_number_of_assignments()))
self.assertEqual(len(ss), ns ** (len(ps) - 2) * (ns) * (ns - 1))
all_states = []
print("testing")
for state in ss:
# print state
# print all_states
self.assertNotIn(state, all_states)
all_states.append(state)
def setUp(self):
"""Build test model and optimizer"""
IMP.test.TestCase.setUp(self)
IMP.set_log_level(IMP.SILENT)
IMP.set_check_level(IMP.NONE)
self.imp_model = IMP.Model()
self.load_density_map("1z5s_10.mrc")
self.load_proteins(["1z5s_A_fitted.pdb", "1z5s_B_fitted.pdb",
"1z5s_C_fitted.pdb", "1z5s_D_fitted.pdb", ])
self.full_sampled_map = IMP.em.SampledDensityMap(
self.scene.get_header())
self.all_ps = []
for mh in self.mhs:
self.all_ps += IMP.core.get_leaves(mh)
self.full_sampled_map.set_particles(self.all_ps)
self.full_sampled_map.resample()
self.scene.calcRMS()
self.full_sampled_map.calcRMS()
self.upper = (
self.scene.get_number_of_voxels(
) * self.scene.get_header(
).dmean * self.full_sampled_map.get_header(
).dmean) / len(
self.mhs)
self.lower = self.scene.get_number_of_voxels(
) * self.scene.calcRMS(
) * self.full_sampled_map.calcRMS(
)
self.norm_factors = [self.upper, self.lower]
def setUp(self):
IMP.test.TestCase.setUp(self)
# setup problem
ndensity=4
nmodel=10
rs=np.random.RandomState()
self.m = IMP.Model()
itrans = IMP.algebra.get_identity_transformation_3d()
self.density_ps=create_random_gaussians(self.m,rs,ndensity,spherical=False)
self.model_ps=create_random_gaussians(self.m,rs,nmodel,spherical=False)
psigma=IMP.Particle(self.m)
si = IMP.isd.Scale.setup_particle(psigma,1.0)
slope=0.0
model_cutoff_dist=1e8
density_cutoff_dist=1e8
update_model=True
self.gem=IMP.isd.GaussianEMRestraint(self.m,IMP.get_indexes(self.model_ps),
IMP.get_indexes(self.density_ps),psigma.get_index(),
model_cutoff_dist,density_cutoff_dist,
slope,
update_model,False)
self.m.add_restraint(self.gem)
self.orig_coords=[IMP.core.XYZ(p).get_coordinates() for p in self.model_ps]
def test_set(self):
"""Testing ClassnameContainerSet"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
print("hi")
c = IMP.container.ClassnameContainerSet(m)
ls = []
cs = []
for i in range(0, 3):
l = IMP.container.ListClassnameContainer(m)
c.add_CLASSFUNCTIONNAME_container(l)
for j in range(0, 3):
t = self.create_FUNCTIONNAME(m)
l.add(t)
cs.append(t)
ret = c.get_contents()
for pi in cs:
self.assertIn(pi, ret)
ret.sort()
# print ret
cs.sort()
# rint cs
self.assertEqual(len(ret), len(cs))
for r, c in zip(ret, cs):
self.assertEqual(r, c)
def test_dependencies(self):
"""Check dependencies with restraints and score states"""
m= IMP.Model("dependencies")
ps=[IMP.Particle(m) for i in range(0,20)]
cs=[DummyScoreState(ips=self._select(ps[:5], 2),
ops= self._select(ps[5:], 2))
for i in range(5)]
for c in cs:
m.add_score_state(c)
rs=[DummyRestraint(ps=self._select(ps, 4))
for i in range(5)]
for r in rs:
m.add_restraint(r)
dg= IMP.get_dependency_graph(m)
#IMP.show_graphviz(dg)
for r in rs:
print "now restraint",r
rcsl=IMP.get_required_score_states([r], dg,
IMP.get_vertex_index(dg))
rdg= IMP.get_dependency_graph(m)
#IMP.show_graphviz(rdg)
ccsl=[]
for n in rdg.get_vertices():
nn= rdg.get_vertex_name(n)
print nn.get_name()
try:
IMP.ScoreState.get_from(nn)
except:
print "not", nn.get_name()
pass
else:
print "found", nn.get_name()
ccsl.append(nn)
def test_set(self):
"""Testing PairContainerSet"""
IMP.set_log_level(IMP.VERBOSE)
m= IMP.Model()
print "hi"
c= IMP.container.PairContainerSet(m)
ls=[]
cs=[]
for i in range(0,3):
l= IMP.container.ListPairContainer(m)
c.add_pair_container(l)
for j in range(0,3):
t=self.create_particle_pair(m)
l.add_particle_pair(t)
cs.append(t)
for p in cs:
self.assertTrue(c.get_contains_particle_pair(p))
ret=[]
for i in range(0, len(cs)):
ret.append(c.get_particle_pair(i))
ret.sort(cmp)
#print ret
cs.sort(cmp)
#rint cs
for i in range(0, len(ret)):
self.assertEqual(cmp(ret[i], cs[i]), 0)
self.assertEqual(c.get_number_of_particle_pairs(), len(cs))
def run_from_config(self, config, output):
"""
Run using work-unit 0 using specified config file,
dumping output to specified output file
return - the resulting simulation data object
"""
IMP.set_log_level( IMP.SILENT );
print "assigning parameter ranges from config"
num=assign_ranges( config, output,
0, True, 10 );
sd= IMP.npctransport.SimulationData(output, False,
self.get_tmp_file_name("out0.rmf"));
print "BEFORE INIT", time.ctime()
IMP.npctransport.initialize_positions(sd, [], False)
print "AFTER INIT", time.ctime()
obd= sd.get_bd()
obd.optimize(2)
print "AFTER OPTIMIZE", time.ctime()
timer= IMP.npctransport.timer();
# # lame test
# rt= sd.get_root()
# rtt= IMP.npctransport.Transporting.setup_particle(rt, True)
# rtf= rt.get_child(0)
# rttf= IMP.npctransport.Transporting.setup_particle(rtf, False)
print "updating stats"
sd.update_statistics(timer, 0);
return sd
def test_set(self):
"""Testing PairsConstraint"""
# write increment an int field
# call evaluate and check that it is incremented
IMP.set_log_level(IMP.VERBOSE)
print "start"
m= IMP.Model()
print "hi"
c= IMP.container.ListPairContainer(m)
cs=[]
for i in range(0,30):
t=self.create_particle_pair(m)
c.add_particle_pair(t)
cs.append(t)
print "dl"
k= IMP.IntKey("thevalue")
f= PairTestModifier(k)
print "apply"
s= IMP.container.PairsConstraint(f, None, c)
print "add"
m.add_score_state(s)
m.update()
for p in cs:
self.assertTrue(particle_pair_has_attribute(p, k))
print "done"
def test_global_min3(self):
"""Test capped caching of restraint scores"""
m = IMP.Model()
p = IMP.Particle(m)
IMP.core.XYZ.setup_particle(p)
lr = LogRestraint(m, [p])
lr.set_maximum_score(0)
pst = IMP.domino.ParticleStatesTable()
s = IMP.domino.XYZStates([IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(0, 0, 1)])
pst.set_particle_states(p, s)
rc = IMP.domino.RestraintCache(pst, 1)
rc.add_restraints([lr])
rft = IMP.domino.RestraintScoreSubsetFilterTable(rc)
f = rft.get_subset_filter(IMP.domino.Subset([p]), [])
f.set_log_level(IMP.VERBOSE)
IMP.set_log_level(IMP.VERBOSE)
# turn off checks to avoid restraint re-evals
IMP.set_check_level(IMP.NONE)
lr.reset()
f.get_is_ok(IMP.domino.Assignment([0]))
f.get_is_ok(IMP.domino.Assignment([0]))
f.get_is_ok(IMP.domino.Assignment([1]))
f.get_is_ok(IMP.domino.Assignment([1]))
f.get_is_ok(IMP.domino.Assignment([0]))
self.assertEqual(lr.count, 3)
def filterAssignments(self, assignments, subset, nodeIndex, rssft):
filteredSubsets = []
restraintList = []
# make dependency graph for stats
for r in IMP.get_restraints([self.model.get_root_restraint_set()]):
restraintList.append(r)
dg = IMP.get_dependency_graph(restraintList)
stateCounter = 0
passedCounter = 0
# create hdf5AssignmentContainer
sFilter = rssft.get_subset_filter(subset, filteredSubsets)
# check each unique state to see if passes filter
filteredAssignments = []
for assignment in assignments:
if (sFilter is None or sFilter.get_is_ok(assignment)):
# add to assignment container if it passes
passedCounter += 1
filteredAssignments.append(assignment)
stateCounter += 1
fraction = (passedCounter * 1.0) / (stateCounter * 1.0)
print("%s states passed out of %s total for this subset (fraction %s)" % (passedCounter, stateCounter, fraction))
if (passedCounter == 0):
print("subset %s had 0 assignments (out of %s) pass. Exiting..." % (subset, stateCounter))
sys.exit()
return filteredAssignments
def test_global_min1(self):
"""Test close pairs list generation"""
m = IMP.Model()
ps = [IMP.Particle(m) for i in range(0, 10)]
psi = IMP.get_indexes(ps)
ds = [IMP.core.XYZR.setup_particle(p) for p in ps]
for d in ds:
d.set_radius(6)
bb = IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(50, 50, 50))
bbs = IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(4, 4, 4))
pst = IMP.domino.ParticleStatesTable()
for p in ps:
v0 = IMP.algebra.get_random_vector_in(bb)
vs = [v0 + IMP.algebra.get_random_vector_in(bbs)
for i in range(0, ns)]
yxz = IMP.domino.XYZStates(vs)
pst.set_particle_states(p, yxz)
allp = IMP.domino.get_possible_interactions(ps, 2, pst)
cpf = IMP.core.GridClosePairsFinder()
cpf.set_distance(1.8)
pst.set_was_used(True)
for rep in range(0, 1000):
for p in ps:
st = pst.get_particle_states(p)
st.load_particle_state(random.sample(range(0, ns), 1)[0], p)
curp = cpf.get_close_pairs(m, psi)
print(len(curp))
for pi in curp:
p = tuple(IMP.get_particles(m, pi))
self.assertTrue(p in allp or (p[1], p[0]) in allp)
def setUp(self):
IMP.test.TestCase.setUp(self)
#IMP.set_log_level(IMP.TERSE)
IMP.set_log_level(0)
self.m = IMP.Model()
data=open(self.get_input_file_name('lyzexp_gpir.dat')).readlines()
data=[map(float,d.split()) for d in data]
self.q=[[i[0]] for i in data]
self.I=[i[1] for i in data]
self.err=[i[2] for i in data]
self.N=10
self.G = Scale.setup_particle(IMP.Particle(self.m), 3.0)
self.G.set_nuisance_is_optimized(False)
self.Rg = Scale.setup_particle(IMP.Particle(self.m), 10.0)
self.Rg.set_nuisance_is_optimized(False)
#put d=15 so we don't use the porod region
self.d = Scale.setup_particle(IMP.Particle(self.m), 15.0)
self.d.set_nuisance_is_optimized(False)
self.s = Scale.setup_particle(IMP.Particle(self.m), 0.0)
self.s.set_nuisance_is_optimized(False)
self.A = Scale.setup_particle(IMP.Particle(self.m), 0.0)
self.A.set_nuisance_is_optimized(False)
self.mean = GeneralizedGuinierPorodFunction(
self.G,self.Rg,self.d,self.s, self.A)
self.tau = Switching.setup_particle(IMP.Particle(self.m), 1.0)
self.tau.set_nuisance_is_optimized(True)
self.lam = Scale.setup_particle(IMP.Particle(self.m), 1.)
self.lam.set_nuisance_is_optimized(True)
self.sig = Scale.setup_particle(IMP.Particle(self.m), 1.0)
self.sig.set_nuisance_is_optimized(True)
self.cov = Covariance1DFunction(self.tau, self.lam, 2.0)
self.gpi = IMP.isd.GaussianProcessInterpolation(self.q, self.I,
self.err, self.N, self.mean, self.cov, self.sig)
self.particles=[self.G,self.Rg,self.d,self.s,self.sig,self.tau,self.lam]
def test_filters(self):
"""Test filters on excluded volume"""
m = IMP.kernel.Model()
m.set_log_level(IMP.base.SILENT)
print "pdb"
h0s=IMP.kernel._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.base.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.base.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 setUp(self):
"""Build test model and optimizer"""
IMP.test.TestCase.setUp(self)
IMP.set_log_level(IMP.SILENT)
self.imp_model = IMP.Model()
self.load_density_map()
self.load_protein("1z5s_A.pdb")
def test_ms_connectivity_graph_2(self):
"""Test for the correctness of the graph 2."""
IMP.set_log_level(IMP.SILENT)
self.ds2[0].set_coordinates(IMP.algebra.Vector3D(1.0, 6.0, 0.0)) # A
self.ds2[1].set_coordinates(IMP.algebra.Vector3D(3.0, 5.0, 0.0)) # A
self.ds2[2].set_coordinates(IMP.algebra.Vector3D(0.0, 4.0, 0.0)) # A
self.ds2[3].set_coordinates(IMP.algebra.Vector3D(1.0, 5.0, 0.0)) # B
self.ds2[4].set_coordinates(IMP.algebra.Vector3D(1.0, 3.0, 0.0)) # B
self.ds2[5].set_coordinates(IMP.algebra.Vector3D(0.0, 2.0, 0.0)) # C
self.ds2[6].set_coordinates(IMP.algebra.Vector3D(0.0, 0.0, 0.0)) # C
self.ds2[7].set_coordinates(IMP.algebra.Vector3D(1.0, 1.0, 0.0)) # D
idk = IMP.StringKey("id")
connections = list()
pps = self.r2.get_connected_pairs()
for p in pps:
conn = sorted([p[0].get_value(idk), p[1].get_value(idk)])
connections.append("%s <-> %s" % (conn[0], conn[1]))
connections.sort()
connections = ", ".join(connections)
self.assertEqual(
connections,
"A <-> A, A <-> B, A <-> B, A <-> B, A <-> B, A <-> C, B <-> B, B <-> C, C <-> C, C <-> D, C <-> D",
)
def _do_test_rot(self, dt):
"""Check rigid body brownian dynamics correlation time"""
print("Testing for dt=", dt)
m = IMP.Model()
p = IMP.Particle(m)
d = IMP.core.XYZR.setup_particle(p)
d.set_radius(10)
rb = IMP.core.RigidBody.setup_particle(
p, IMP.algebra.ReferenceFrame3D())
rb.set_coordinates_are_optimized(True)
dd = IMP.atom.RigidBodyDiffusion.setup_particle(p)
nD = dd.get_rotational_diffusion_coefficient()
dd.set_rotational_diffusion_coefficient(nD)
# print dd.get_rotational_diffusion_coefficient(),
# dd.get_diffusion_coefficient()
bd = IMP.atom.BrownianDynamics(m)
bd.set_scoring_function([])
bd.set_maximum_time_step(dt)
angles = []
rots = []
for i in range(0, 3000):
bd.optimize(1)
rots.append(
rb.get_rotation())
angle = IMP.algebra.get_axis_and_angle(rots[-1])
angles.append(angle[1])
# print angles
real_D= dd.get_rotational_diffusion_coefficient()
IMP.set_log_level(IMP.PROGRESS)
estimate_D= IMP.atom.get_rotational_diffusion_coefficient(rots, dt)
print("Mean rot angle per dt/real rotD/estimated rotD: ",
IMP.atom.get_diffusion_angle(real_D, dt),
real_D, estimate_D)
self.assertAlmostEqual(real_D, estimate_D, delta= .05*(real_D+estimate_D))
return estimate_D
def _testit(self, writer, nm):
m= IMP.Model()
o= IMP.core.SteepestDescent()
o.set_model(m)
p0= IMP.Particle(m)
d0= IMP.core.XYZR.setup_particle(p0)
d0.set_radius(1.5)
d0.set_x(0)
d0.set_y(0)
d0.set_z(0)
p1= IMP.Particle(m)
d1= IMP.core.XYZR.setup_particle(p1)
d1.set_x(1)
d1.set_y(1)
d1.set_z(1)
d1.set_radius(1)
IMP.set_log_level(IMP.VERBOSE)
a= IMP.display.WriteOptimizerState(writer)
g= IMP.core.XYZRGeometry(d0)
#ge= IMP.core.XYZRGeometryExtractor(rk)
ps= IMP.container.ListSingletonContainer(m)
ps.add_particle(p1)
#a.add_geometry(ge, ps)
a.add_geometry(g)
o.add_optimizer_state(a)
a.update()
a.update()
a.update()
open(nm.replace("%1%", "2"), "r").read()
self.assertRaises(IOError, self._testopen, nm)
def test_it(self):
"""Test cover refined"""
m= IMP.Model()
IMP.set_log_level(IMP.MEMORY)
n= random.randrange(1,10)
ps=[]
ds=IMP.core.XYZRs()
pp= IMP.Particle(m)
hd= IMP.core.Hierarchy.setup_particle(pp)
dd= IMP.core.XYZR.setup_particle(pp)
for i in range(0,n):
p= IMP.Particle(m)
d=IMP.core.XYZR.setup_particle(p)
ps.append(p)
ds.append(d)
d.set_coordinates(IMP.algebra.get_random_vector_in(IMP.algebra.get_unit_bounding_box_3d()))
d.set_radius(random.uniform(0,1))
hd.add_child(IMP.core.Hierarchy.setup_particle(p))
r= IMP.core.ChildrenRefiner(IMP.core.Hierarchy.get_default_traits())
c= IMP.core.CentroidOfRefined(r)
c.apply(pp)
bb= IMP.algebra.BoundingBox3D()
cd= IMP.core.XYZ(pp)
for i in range(0,n):
d= IMP.core.XYZ(hd.get_child(i).get_particle())
bb+=IMP.algebra.BoundingBox3D(d.get_coordinates())
self.assertTrue(bb.get_contains(cd.get_coordinates()))
def _test_score(self):
"""Test protein ligand restraint 1"""
m = IMP.Model()
IMP.set_log_level(IMP.SILENT)
p = IMP.atom.read_pdb(self.get_input_file_name("1d3d-protein.pdb"),
m)
l = IMP.atom.read_mol2(self.get_input_file_name("1d3d-ligands.mol2"),
m)
# print "protein"
# IMP.atom.show_molecular_hierarchy(p)
# print "ligand"
# IMP.atom.show_molecular_hierarchy(l)
print("rigid bodies")
rbp = IMP.atom.create_rigid_body(p)
rbl = IMP.atom.create_rigid_body(l)
it = IMP.algebra.Transformation3D(
IMP.algebra.get_identity_rotation_3d(),
IMP.algebra.Vector3D(0, 0, 0))
rbp.set_transformation(it)
rbl.set_transformation(it)
IMP.atom.write_mol2(
l,
self.get_tmp_file_name(
"transformed_ligand.mol2"))
IMP.atom.write_pdb(
p,
self.get_tmp_file_name(
"transformed_protein.pdb"))
print("evaluate")
# IMP.set_log_level(IMP.VERBOSE)
r = IMP.atom.ProteinLigandRestraint(p, l, 15.0)
raw = r.evaluate(False)
deriv = r.evaluate(True)
self.assertAlmostEqual(raw, deriv, delta=.1 * (raw + deriv))
def test_score_2(self):
"""Test protein ligand restraint 2"""
m = IMP.Model()
IMP.set_log_level(IMP.SILENT)
p = IMP.atom.read_pdb(self.get_input_file_name("1d3d-protein.pdb"),
m, IMP.atom.NonWaterNonHydrogenPDBSelector())
l = IMP.atom.read_mol2(self.get_input_file_name("1d3d-ligands.mol2"),
m, IMP.atom.NonHydrogenMol2Selector())
#patms= IMP.atom.get_by_type(p, IMP.atom.ATOM_TYPE)
# for cp in patms:
# print "Read patom "+str(IMP.core.XYZ(cp.get_particle()).get_coordinates())+":Type: \""+str(IMP.atom.Atom(cp.get_particle()).get_atom_type())+"\" atom number: "+str(IMP.atom.Atom(cp.get_particle()).get_input_index())
#latms= IMP.atom.get_by_type(l, IMP.atom.ATOM_TYPE)
# for cp in latms:
# print "Read latom
# "+str(IMP.core.XYZ(cp.get_particle()).get_coordinates())+":Type:
# \""+str(IMP.atom.Atom(cp.get_particle()).get_atom_type())+"\" atom
# number: "+str(IMP.atom.Atom(cp.get_particle()).get_input_index())
print("evaluate")
ls = IMP.atom.get_by_type(l, IMP.atom.RESIDUE_TYPE)
self.assertEqual(len(ls), 2)
IMP.set_log_level(IMP.SILENT)
r0 = IMP.atom.ProteinLigandRestraint(p, ls[0], 6.0)
r1 = IMP.atom.ProteinLigandRestraint(p, ls[1], 6.0)
print(r0.evaluate(False))
print(r1.evaluate(False))
self.assertAlmostEqual(r0.evaluate(False), 8.3, delta=1)
self.assertAlmostEqual(r1.evaluate(False), 6.5, delta=1)
def setUp(self):
IMP.test.TestCase.setUp(self)
IMP.set_log_level(IMP.SILENT)
# Initial values and names of files
self.fn_in = self.get_input_file_name('1tdx_sampled.mrc')
self.resolution=6.0
self.fn_coords = self.get_input_file_name('1tdx.pdb')
self.pixel_size=1.0
self.mrc_rw = IMP.em.MRCReaderWriter()
self.EM_map = IMP.em.read_map(self.fn_in,self.mrc_rw)
self.EM_map.std_normalize()
self.EM_map.get_header_writable().compute_xyz_top()
self.mdl=IMP.Model()
mh=IMP.atom.read_pdb(self.fn_coords,self.mdl,IMP.atom.CAlphaPDBSelector())
IMP.atom.add_radii(mh)
self.atoms=IMP.core.get_leaves(mh)
self.model_map = IMP.em.SampledDensityMap(self.atoms, self.resolution,
self.pixel_size)
self.xo=self.model_map.get_header().get_xorigin()
self.yo=self.model_map.get_header().get_yorigin()
self.zo=self.model_map.get_header().get_zorigin()
self.EM_map = IMP.em.SampledDensityMap(self.atoms, self.resolution, self.pixel_size)
self.EM_map.std_normalize()
self.EM_map.get_header_writable().compute_xyz_top()
self.ccc = IMP.em.CoarseCC()
self.ccc_intervals = IMP.em.CoarseCCatIntervals()
def test_stats(self):
"""Test MonteCarlo stats"""
m = IMP.Model()
IMP.set_log_level(IMP.WARNING)
mc = IMP.core.MonteCarlo(m)
mc.set_log_level(IMP.WARNING)
ps = []
bb = IMP.algebra.get_unit_bounding_box_3d()
for i in range(0, 10):
p = IMP.Particle(m)
d = IMP.core.XYZR.setup_particle(p)
ps.append(d)
d.set_coordinates(IMP.algebra.get_random_vector_in(bb))
d.set_radius(.1)
d.set_coordinates_are_optimized(True)
cpc = IMP.container.ConsecutivePairContainer(m, ps)
hps = IMP.core.HarmonicDistancePairScore(1, 100)
r = IMP.container.PairsRestraint(hps, cpc)
mc.set_scoring_function([r])
ms = [IMP.core.BallMover([x], .1) for x in ps]
mv = IMP.core.SerialMover(ms)
mc.add_mover(mv)
self.assertEqual(mc.get_number_of_accepted_steps(), 0)
self.assertEqual(mc.get_number_of_upward_steps(), 0)
self.assertEqual(mc.get_number_of_downward_steps(), 0)
self.assertEqual(mc.get_number_of_proposed_steps(), 0)
for i in range(0, 10):
mc.optimize(100)
self.assertEqual(mc.get_number_of_accepted_steps(),
mc.get_number_of_upward_steps() +
mc.get_number_of_downward_steps())
self.assertEqual(mc.get_number_of_proposed_steps(), 100)
def test_rops(self):
"""Check that LowestRefinedPairScore returns the lowest"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
pp0 = m.add_particle("pp0")
pp1 = m.add_particle("pp1")
hpp = [IMP.core.Hierarchy.setup_particle(m, pp0),
IMP.core.Hierarchy.setup_particle(m, pp1)]
ds = [[], []]
for i in range(0, 10):
p = IMP.Particle(m)
d = IMP.core.XYZ.setup_particle(p)
d.set_coordinates(IMP.algebra.get_random_vector_in(
IMP.algebra.get_unit_bounding_box_3d()))
ds[i % 2].append(d)
hp = IMP.core.Hierarchy.setup_particle(p)
hpp[i % 2].add_child(hp)
# could be more clever
md = 1000000
for p0 in ds[0]:
for p1 in ds[1]:
d = IMP.core.get_distance(p0, p1)
if d < md:
md = d
pr = IMP.core.ChildrenRefiner(IMP.core.Hierarchy.get_default_traits())
cps = IMP.core.Linear(0, 1)
dps = IMP.core.DistancePairScore(cps)
rps = IMP.misc.LowestRefinedPairScore(pr, dps)
self.assertAlmostEqual(rps.evaluate_index(m, (pp0, pp1),
None), .9 * md, delta=1.1 * md)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.set_log_level(IMP.MEMORY)
IMP.set_log_level(0)
self.m = IMP.Model()
self.kappa = Scale.setup_particle(IMP.Particle(self.m), 1.0)
self.DA = IMP.DerivativeAccumulator()
def test_create_one(self):
"""Testing create_rigid_body"""
count=1
success=0
for i in range(0, count):
m= IMP.Model()
IMP.set_log_level(IMP.SILENT)
print "creating"
p= self._create_hierarchy(m)
print "created", p
print "wrapping"
h=IMP.core.Hierarchy(p)
print "getting children"
children=h.get_children()
print "wrapping children"
cs=IMP.core.XYZs(children)
print "setting up"
rbd=IMP.core.RigidBody.setup_particle(p, cs)
print "set up"
p.show()
rbd.set_coordinates_are_optimized(True)
self. _add_rb_restraints(rbd)
cg= IMP.core.ConjugateGradients()
cg.set_model(m)
print "Initial score is " + str(m.evaluate(False))
cg.optimize(1000)
if m.evaluate(False) < .1:
success=success+1
self.assertGreater(success, count/2)
def get_version_info(self):
return IMP.VersionInfo("Daniel Russel", "0.5")
import IMP
import RMF
import IMP.atom
import IMP.algebra
import IMP.rmf
import IMP.pmi
import IMP.pmi.topology
import IMP.pmi.dof
import IMP.pmi.macros
import IMP.pmi.restraints.em
import tempfile
import os
###################### SYSTEM SETUP #####################
# Preliminaries
mdl = IMP.Model()
seqs = IMP.pmi.topology.Sequences(IMP.pmi.get_example_path('data/1WCM.fasta'))
# Setup just one molecule
s = IMP.pmi.topology.System(mdl)
st = s.create_state()
mol = st.create_molecule("Rpn4",sequence=seqs["1WCM:D"],chain_id="D")
atomic_res = mol.add_structure(IMP.pmi.get_example_path('data/1WCM_fitted.pdb'),
chain_id="D",
offset=0)
# Below we create a GMM approximation for this moleucle
# This "DENSITY" representation is used in the GaussianEMRestraint (and others in the future)
# For structure regions we "fit" GMM components to all atom centers
mol.add_representation(atomic_res,
resolutions=[1,10],
def __init__(self,
representation=None,
images=None,
pixel_size=None,
image_resolution=None,
projection_number=None,
micrographs_number=None,
resolution=None,
n_components=1,
hier=None):
"""Constructor.
@param representation DEPRECATED, pass 'hier' instead
@param images 2D class average filenames in PGM text format
@param pixel_size Pixel size in angstroms
@param image_resolution Estimated resolution of the images
in angstroms
@param projection_number Number of projections of the model
to generate and fit to images. The lower the number, the
faster the evaluation, but the lower the accuracy
@param micrographs_number Number of micrograph particles that
were used to generate the class averages, if known
@param resolution Which level of
[model representation](@ref pmi_resolution) to use in the fit
@param n_components Number of the largest components to be
considered for the EM image
@param hier The root hierarchy for applying the restraint
"""
import IMP.em2d
# check input
if images is None:
raise Exception("Must pass images")
if pixel_size is None:
raise Exception("Must pass pixel size")
if image_resolution is None:
raise Exception("must pass image resolution")
self.datasets = []
for image in images:
l = ihm.location.InputFileLocation(
image, details="Electron microscopy class average")
d = ihm.dataset.EM2DClassDataset(l)
self.datasets.append(d)
if representation:
for p, state in representation._protocol_output:
for i in range(len(self.datasets)):
p.add_em2d_restraint(state, self, i, resolution,
pixel_size, image_resolution,
projection_number, micrographs_number)
# PMI1/2 selection
if representation is None and hier is not None:
self.m = hier.get_model()
particles = IMP.atom.Selection(
hier, resolution=resolution).get_selected_particles()
elif hier is None and representation is not None:
self.m = representation.prot.get_model()
particles = IMP.pmi.tools.select(representation,
resolution=resolution)
else:
raise Exception("EM2D: must pass hier or representation")
self.weight = 1.0
self.rs = IMP.RestraintSet(self.m, 'em2d')
self.label = "None"
# read PGM FORMAT images
# format conversion recommendataion - first run "e2proc2d.py $FILE ${NEW_FILE}.pgm"
# then, run "convert ${NEW_FILE}.pgm -compress none ${NEW_FILE2}.pgm"
if (
n_components >= 2
): # Number of the largest components to be considered for the EM image
em2d = IMP.em2d.PCAFitRestraint(particles, images, pixel_size,
image_resolution,
projection_number, True,
n_components)
else:
em2d = IMP.em2d.PCAFitRestraint(particles, images, pixel_size,
image_resolution,
projection_number, True)
self._em2d_restraint = em2d
self._num_images = len(images)
self.rs.add_restraint(em2d)
def __init__(self,
representation=None,
images=None,
pixel_size=None,
image_resolution=None,
projection_number=None,
resolution=None,
hier=None):
"""Constructor.
@param representation DEPRECATED, pass 'hier' instead
@param images SPIDER FORMAT images (format conversion should be done through EM2EM)
@param pixel_size sampling rate of the available EM images (angstroms)
@param image_resolution resolution at which you want to generate the projections of the model
In principle you want "perfect" projections, so use the highest resolution
@param projection_number Number of projections of the model (coarse registration) to
estimate the registration parameters
@param resolution Which level of
[model representation](@ref pmi_resolution) to use in the fit
@param n_components Number of the largest components to be
considered for the EM image
@param hier The root hierarchy for applying the restraint
"""
import IMP.em2d
# check input
if images is None:
raise Exception("EM2D_FFT: must pass images")
if pixel_size is None:
raise Exception("EM2D_FFT: must pass pixel size")
if image_resolution is None:
raise Exception("EM2D_FFT: must pass image resolution")
if projection_number is None:
raise Exception("EM2D_FFT: must pass projection_number")
# PMI1/2 selection
if representation is None and hier is not None:
self.m = hier.get_model()
particles = IMP.atom.Selection(
hier, resolution=resolution).get_selected_particles()
elif hier is None and representation is not None:
self.m = representation.prot.get_model()
particles = IMP.pmi.tools.select(representation,
resolution=resolution)
else:
raise Exception("EM2D: must pass hier or representation")
self.weight = 1.0
self.rs = IMP.RestraintSet(self.m, 'em2d_FFT')
self.label = "None"
# read
srw = IMP.em2d.SpiderImageReaderWriter()
imgs = IMP.em2d.read_images(images, srw)
rows = imgs[0].get_header().get_number_of_rows()
cols = imgs[0].get_header().get_number_of_columns()
params = IMP.em2d.Em2DRestraintParameters(pixel_size, image_resolution,
projection_number)
# This method (recommended) uses preprocessing of the images and projections to speed-up the registration
params.coarse_registration_method = IMP.em2d.ALIGN2D_PREPROCESSING
params.optimization_steps = 50
params.simplex_initial_length = 0.1
params.simplex_minimum_size = 0.02
# use true if you want to save the projections from the model that best match the EM images
params.save_match_images = False
######################
# set up the em2D restraint
######################
score_function = IMP.em2d.EM2DScore()
em2d_restraint = IMP.em2d.Em2DRestraint(self.m)
em2d_restraint.setup(score_function, params)
em2d_restraint.set_images(imgs)
em2d_restraint.set_fast_mode(5)
em2d_restraint.set_name("em2d_restraint")
print("len(particles) = ", len(particles))
container = IMP.container.ListSingletonContainer(self.m, particles)
em2d_restraint.set_particles(container)
self.rs.add_restraint(em2d_restraint)
def fit_dirichlet_gmm_to_points(points,
n_components,
mdl,
ps=[],
num_iter=100,
covariance_type='full',
mass_multiplier=1.0):
"""fit a GMM to some points. Will return core::Gaussians.
if no particles are provided, they will be created
points: list of coordinates (python)
n_components: number of gaussians to create
mdl: IMP Model
ps: list of particles to be decorated. if empty, will add
num_iter: number of EM iterations
covariance_type: covar type for the gaussians. options: 'full', 'diagonal', 'spherical'
init_centers: initial coordinates of the GMM
force_radii: fix the radii (spheres only)
force_weight: fix the weights
mass_multiplier: multiply the weights of all the gaussians by this value
"""
new_sklearn = True
try:
from sklearn.mixture import BayesianGaussianMixture
except ImportError:
from sklearn.mixture import DPGMM
new_sklearn = False
### create and fit GMM
print('using dirichlet prior')
if new_sklearn:
gmm = BayesianGaussianMixture(
weight_concentration_prior_type='dirichlet_process',
n_components=n_components, max_iter=num_iter,
covariance_type=covariance_type)
else:
gmm = DPGMM(n_components=n_components, n_iter=num_iter,
covariance_type=covariance_type)
gmm.fit(points)
#print('>>> GMM score',gmm.score(points))
#print gmm.covars_
#print gmm.weights_
#print gmm.means_
### convert format to core::Gaussian
if not new_sklearn:
gmm.precisions_ = gmm.precs_
for ng in range(n_components):
invcovar=gmm.precisions_[ng]
covar=np.linalg.inv(invcovar)
if covar.size==3:
covar=np.diag(covar).tolist()
else:
covar=covar.tolist()
center=list(gmm.means_[ng])
weight=mass_multiplier*gmm.weights_[ng]
if ng>=len(ps):
ps.append(IMP.Particle(mdl))
shape=IMP.algebra.get_gaussian_from_covariance(covar,IMP.algebra.Vector3D(center))
g=IMP.core.Gaussian.setup_particle(ps[ng],shape)
IMP.atom.Mass.setup_particle(ps[ng],weight)
IMP.core.XYZR.setup_particle(ps[ng],sqrt(max(g.get_variances())))
def fit_gmm_to_points(points,
n_components,
mdl,
ps=[],
num_iter=100,
covariance_type='full',
min_covar=0.001,
init_centers=[],
force_radii=-1.0,
force_weight=-1.0,
mass_multiplier=1.0):
"""fit a GMM to some points. Will return the score and the Akaike score.
Akaike information criterion for the current model fit. It is a measure
of the relative quality of the GMM that takes into account the
parsimony and the goodness of the fit.
if no particles are provided, they will be created
points: list of coordinates (python)
n_components: number of gaussians to create
mdl: IMP Model
ps: list of particles to be decorated. if empty, will add
num_iter: number of EM iterations
covariance_type: covar type for the gaussians. options: 'full', 'diagonal', 'spherical'
min_covar: assign a minimum value to covariance term. That is used to have more spherical
shaped gaussians
init_centers: initial coordinates of the GMM
force_radii: fix the radii (spheres only)
force_weight: fix the weights
mass_multiplier: multiply the weights of all the gaussians by this value
dirichlet: use the DGMM fitting (can reduce number of components, takes longer)
"""
new_sklearn = False
try:
from sklearn.mixture import GMM
except ImportError:
from sklearn.mixture import GaussianMixture
new_sklearn = True
print('creating GMM with n_components',n_components,'n_iter',num_iter,'covar type',covariance_type)
if new_sklearn:
# aic() calls size() on points, so it needs to be
# a numpy array, not a list
points = np.array(points)
weights_init = precisions_init = None
if force_radii != -1.0:
print('warning: radii can no longer be forced, but setting '
'initial values to ', force_radii)
precisions_init = np.array([[1./force_radii]*3
for i in range(n_components)])
if force_weight != -1.0:
print('warning: weights can no longer be forced, but setting '
'initial values to ', force_weight)
weights_init = np.array([force_weight]*n_components)
gmm = GaussianMixture(n_components=n_components,
max_iter=num_iter,
covariance_type=covariance_type,
weights_init=weights_init,
precisions_init=precisions_init,
means_init=None if init_centers==[]
else init_centers)
else:
params='m'
init_params='m'
if force_radii==-1.0:
params+='c'
init_params+='c'
else:
covariance_type='spherical'
print('forcing spherical with radii',force_radii)
if force_weight==-1.0:
params+='w'
init_params+='w'
else:
print('forcing weights to be',force_weight)
gmm = GMM(n_components=n_components, n_iter=num_iter,
covariance_type=covariance_type, min_covar=min_covar,
params=params, init_params=init_params)
if force_weight!=-1.0:
gmm.weights_=np.array([force_weight]*n_components)
if force_radii!=-1.0:
gmm.covars_=np.array([[force_radii]*3 for i in range(n_components)])
if init_centers!=[]:
gmm.means_=init_centers
print('fitting')
model=gmm.fit(points)
score=gmm.score(points)
akaikescore=model.aic(points)
#print('>>> GMM score',gmm.score(points))
### convert format to core::Gaussian
if new_sklearn:
covars = gmm.covariances_
else:
covars = gmm.covars_
for ng in range(n_components):
covar=covars[ng]
if covar.size==3:
covar=np.diag(covar).tolist()
else:
covar=covar.tolist()
center=list(gmm.means_[ng])
weight=mass_multiplier*gmm.weights_[ng]
if ng>=len(ps):
ps.append(IMP.Particle(mdl))
shape=IMP.algebra.get_gaussian_from_covariance(covar,IMP.algebra.Vector3D(center))
g=IMP.core.Gaussian.setup_particle(ps[ng],shape)
IMP.atom.Mass.setup_particle(ps[ng],weight)
IMP.core.XYZR.setup_particle(ps[ng],sqrt(max(g.get_variances())))
return (score,akaikescore)
def get_version_info(self):
return IMP.get_module_version_info()
def test_bonded(self):
"""Check brownian dynamics with rigid bodies"""
self.skipTest("TAMD is temporarily disabled")
# Disable internal checks, since they make the test take way too long
IMP.set_check_level(IMP.USAGE)
m = IMP.Model()
m.set_log_level(IMP.SILENT)
cores=[]
for i in range(10):
cores.append( self._create_tamd_centroid(m) )
# p2, fparticles2, p2S = self._create_tamd_centroid(m)
# p3, fparticles3, p3S = self._create_tamd_centroid(m)
for p in ([cores[0][0]] + cores[0][1]+ [cores[0][2]] ):
IMP.display.Colored.setup_particle( p, IMP.display.Color(1, 0, 0) )
for p in ([cores[1][0]] + cores[1][1]+ [cores[1][2]] ):
IMP.display.Colored.setup_particle( p, IMP.display.Color(0, 1, 0) )
for p in ([cores[2][0]] + cores[2][1]+ [cores[2][2]] ):
IMP.display.Colored.setup_particle( p, IMP.display.Color(0, 0, 1) )
for p in ([cores[3][0]] + cores[3][1]+ [cores[3][2]] ):
IMP.display.Colored.setup_particle( p, IMP.display.Color(1, 1, 0) )
# Add Restraints:
spring = IMP.core.HarmonicDistancePairScore(0, 0.00000001)
excluded_vol = IMP.core.SoftSpherePairScore(100)
attraction = IMP.core.HarmonicSphereDistancePairScore(5, 5)
R=[] # restraints
# TAMD:
for core in cores:
r=IMP.core.PairRestraint(m, spring, (core[0], core[2]))
R.append(r)
# Repulsion between fine particles
for core1 in cores:
for p1 in core1[1]:
for core2 in cores:
for p2 in core2[1]:
if(p1 == p2): continue
r = IMP.core.PairRestraint(m, excluded_vol,
(p1, p2), "Excluded_vol")
R.append(r)
# Attraction between consecutive particles (within or between cores)
for core in cores:
for p1,p2 in zip(core[1][0:-1],core[1][1:]):
r = IMP.core.PairRestraint(m, attraction, (p1, p2), "Chain")
R.append(r)
for core1,core2 in zip(cores[0:-1],cores[1:]):
r = IMP.core.PairRestraint(m, attraction,
(core1[1][-1], core2[1][0]), "Interchain")
R.append(r)
print(R)
# Define BD
bd = IMP.atom.BrownianDynamicsTAMD(m)
sf = IMP.core.RestraintsScoringFunction(R)
bd.set_maximum_time_step(5)
# Attach RMF
# RMF.set_log_level("Off")
rmf_fname = self.get_tmp_file_name("bd_rb_NOtamd.rmf")
rmf = RMF.create_rmf_file(rmf_fname)
print("RMF: ", rmf_fname)
all_particles=[]
for core in cores:
for p in [core[0]] + core[1] + [core[2]]:
IMP.rmf.add_hierarchy(rmf, p)
IMP.rmf.add_restraints(rmf, R)
sf.set_log_level(IMP.SILENT)
os = IMP.rmf.SaveOptimizerState(m, rmf)
os.set_log_level(IMP.SILENT)
os.set_period(10)
bd.set_scoring_function(sf)
bd.add_optimizer_state(os)
IMP.set_log_level(IMP.VERBOSE)
os.update_always("Init position")
IMP.set_log_level(IMP.SILENT)
for i in range(100):
bd.optimize(5)
m.update()
os.update_always("Init opt %d" % i)
for core in cores:
centroid = IMP.core.XYZ(core[0]).get_coordinates()
IMP.core.XYZ(core[2]).set_coordinates( centroid )
max_cycles = 50
round_cycles = 25
total_cycles = 0
e_threshold = 2
for i in range(max_cycles // round_cycles):
bd.optimize(round_cycles)
energy = sf.evaluate(False)
total_cycles += round_cycles
print("energy after %d cycles = %.2f"
% (total_cycles, energy))
r = IMP.container.PairsRestraint(s, lpc)
r.set_maximum_score(.1)
space = IMP.domino.XYZStates(
[IMP.algebra.Vector3D(i, 0, 0) for i in range(0, 6)])
pst = IMP.domino.ParticleStatesTable()
for p in ps:
pst.set_particle_states(p, space)
m.set_log_level(IMP.base.SILENT)
# make sure to break up the
mt = IMP.domino.get_merge_tree([r], pst)
try:
IMP.show_graphviz(mt)
except:
print("Unable to display graph using 'dot'")
rc = IMP.domino.RestraintCache(pst)
rc.add_restraints([r])
filters = [
IMP.domino.RestraintScoreSubsetFilterTable(rc),
IMP.domino.ExclusionSubsetFilterTable(pst)
]
leaf_table = IMP.domino.BranchAndBoundAssignmentsTable(pst, filters)
# create a database to store the results
name = IMP.create_temporary_file_name("assignments", ".hdf5")
root = RMF.HDF5.create_file(name)
# recurse down the tree getting the assignments and printing them
def __init__(self, model, particles):
IMP.kernel.Restraint.__init__(self, model, "WoodsFunc %1%")
self.particles = particles
self.index = IMP.FloatKey("x")
#--------------------------
# Create movers
#--------------------------
# rigid body movement params
rb_max_trans = 1.00
rb_max_rot = 0.01
# flexible bead movement
bead_max_trans = 2.00
#--------------------------------
# Build the Model Representation
#--------------------------------
# Initialize model
m = IMP.Model()
# Create list of components from topology file
topology = IMP.pmi.topology.TopologyReader(topology_file,
pdb_dir=datadirectory,
fasta_dir=datadirectory)
domains = topology.get_components()
bs = IMP.pmi.macros.BuildSystem(m)
bs.add_state(topology)
representation, dof = bs.execute_macro(max_rb_trans=rb_max_trans,
max_rb_rot=rb_max_rot,
max_bead_trans=bead_max_trans)
# representation.shuffle_configuration(50)
def create_singleton_score(self):
uf = IMP.core.Linear(0, 1)
return IMP.core.AttributeSingletonScore(uf, IMP.FloatKey("thekey"))
import IMP.pmi.macros
import sys, os
# most common settings
num_top_models = 500
run_number = 1
merge_directories = ["../run" + str(run_number) + "/"]
prefiltervalue = 2000
out_dir = "kmeans_r%i_m%i/" % (run_number, num_top_models)
#################################
# should not have to change below
##################################
model = IMP.Model()
# initialize the macro
mc = IMP.pmi.macros.AnalysisReplicaExchange0(
model, merge_directories=merge_directories)
# fields that have to be extracted for the stat file
feature_list = [
"ISDCrossLinkMS_Distance_intrarb", "ISDCrossLinkMS_Distance_interrb",
"ISDCrossLinkMS_Data_Score", "GaussianEMRestraint_None",
"SimplifiedModel_Linker_Score_None", "ISDCrossLinkMS_Psi",
"ISDCrossLinkMS_Sigma"
]
# Dictionary of densities to be calculated
# the key is the name of the file and the value is the selection
def test_get_set_source(self):
mdl = IMP.Model()
p = IMP.Particle(mdl)
s = IMP.atom.StructureSource.setup_particle(p, '1ABC', 'G')
self.assertEqual(s.get_source_id(), '1ABC')
self.assertEqual(s.get_source_chain_id(), 'G')
def test_process_output_v1(self):
"""Test reading stat file (v1)"""
with IMP.allow_deprecated():
self._check_stat_file(self.get_input_file_name(
"./output1/statv1.out"))
## \example core/rigid_bodies.py
# This example shows how to set up rigid bodies, one per residue in a protein. A score
# state is then used to ensure that the bodies remain rigid during the optimization process.
#
import IMP
import IMP.core
import IMP.atom
import IMP.container
import sys
IMP.setup_from_argv(sys.argv, "rigid bodies")
m = IMP.Model()
# create a new IMP.atom.Hierarchy for the pdb file
mp1 = IMP.atom.read_pdb(IMP.core.get_example_path('example_protein.pdb'), m)
chains = IMP.atom.get_by_type(mp1, IMP.atom.CHAIN_TYPE)
rd = IMP.atom.Hierarchy(chains[0])
# Create a rigid body from the first chain
# note that rbs != chains[0] as the bounding volume for rbs needs to include all of the
# chain, but chains[0] might have a smaller sphere associated with it.
rbs = IMP.atom.create_rigid_body(chains[0])
print("all done")
## \example kernel/graph.py
# A simple example showing how to use the graph interface for in python.
from __future__ import print_function
import IMP
import sys
IMP.setup_from_argv(sys.argv, "Graph interface")
m = IMP.Model()
# An undirected graph with an IMP::Object for each node
g = IMP.DependencyGraph()
vs = []
ps = []
for i in range(0, 10):
ps.append(IMP.Particle(m))
vs.append(g.add_vertex(ps[-1]))
g.add_edge(vs[0], vs[1])
g.add_edge(vs[1], vs[2])
# try to use the altgraph package to visualize
IMP.show_graphviz(g)
try:
IMP.show_graphviz(g)
except:
print("Oh well, no altgraph")
try:
import matplotlib
# the engine to be used must be selected before pyplot is imported
matplotlib.use("macosx")
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.set_log_level(IMP.MEMORY)
IMP.set_log_level(0)
self.m = IMP.kernel.Model()
self.w = Weight.setup_particle(IMP.kernel.Particle(self.m))
def test_shuffle_deep(self):
"""Test moving rbs, fbs"""
mdl = IMP.Model()
s = IMP.pmi.topology.System(mdl)
seqs = IMP.pmi.topology.Sequences(
self.get_input_file_name('chainA.fasta'))
st1 = s.create_state()
mol = st1.create_molecule("GCP2_YEAST",
sequence=seqs["GCP2_YEAST"][:100],
chain_id='A')
atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'),
chain_id='A',
res_range=(1, 100))
mol.add_representation(mol.get_atomic_residues(), resolutions=[10])
mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10])
mol2 = mol.create_clone('B')
mol3 = st1.create_molecule("GCP2_YEAST_BEADS",
sequence=seqs["GCP2_YEAST"][:100],
chain_id='C')
mol3.add_representation(mol3.get_non_atomic_residues(),
resolutions=[10])
hier = s.build()
dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
dof.create_rigid_body(mol,
nonrigid_parts=mol.get_non_atomic_residues())
dof.create_rigid_body(mol2,
nonrigid_parts=mol2.get_non_atomic_residues())
dof.create_flexible_beads(mol3.get_non_atomic_residues(),
max_trans=1.0)
rbs, fbs = IMP.pmi.tools.get_rbs_and_beads([hier])
rbs_trans_before = {}
fbs_position_before = {}
rbs_trans_after = {}
fbs_position_after = {}
for rb in rbs:
rbs_trans_before[rb] = rb.get_reference_frame(
).get_transformation_to()
for fb in fbs:
if IMP.core.NonRigidMember.get_is_setup(fb):
fbs_position_before[fb] = \
IMP.core.NonRigidMember(fb).get_internal_coordinates()
else:
fbs_position_before[fb] = IMP.core.XYZ(fb).get_coordinates()
IMP.pmi.tools.shuffle_configuration(hier)
for rb in rbs:
rbs_trans_after[rb] = rb.get_reference_frame(
).get_transformation_to()
for fb in fbs:
if IMP.core.NonRigidMember.get_is_setup(fb):
fbs_position_after[fb] = \
IMP.core.NonRigidMember(fb).get_internal_coordinates()
else:
fbs_position_after[fb] = IMP.core.XYZ(fb).get_coordinates()
for fb in fbs:
position_after = fbs_position_after[fb]
position_before = fbs_position_before[fb]
for i in [0, 1, 2]:
self.assertNotEqual(position_after[i], position_before[i])
for rb in rbs:
position_after = rbs_trans_after[rb].get_translation()
position_before = rbs_trans_before[rb].get_translation()
rotation_after = rbs_trans_after[rb].get_rotation(
) * IMP.algebra.Vector3D(1, 1, 1)
rotation_before = rbs_trans_before[rb].get_rotation(
) * IMP.algebra.Vector3D(1, 1, 1)
for i in [0, 1, 2]:
self.assertNotEqual(position_after[i], position_before[i])
self.assertNotEqual(rotation_after[i], rotation_before[i])
def create_rigid_body(self,
rigid_parts,
nonrigid_parts=None,
max_trans=1.0,
max_rot=0.1,
nonrigid_max_trans=0.1,
resolution='all',
name=None):
"""Create rigid body constraint and mover
@param rigid_parts Can be one of the following inputs:
IMP Hierarchy, PMI System/State/Molecule/TempResidue, a list/set (of list/set) of them
or a RigidBody object.
Must be uniform input, however. No mixing object types.
@param nonrigid_parts Same input format as rigid_parts.
Must be a subset of rigid_parts particles.
@param max_trans Maximum rigid body translation
@param max_rot Maximum rigid body rotation
@param nonrigid_max_trans Maximum step for the nonrigid (bead) particles
@param resolution Only used if you pass PMI objects. Probably you want 'all'.
@param name Rigid body name (if None, use IMP default)
\note If you want all resolutions, pass PMI objects because this function will get them all.
Alternatively you can do your selection elsewhere and just pass hierarchies.
Returns tuple (rb_movers,rb_object)
"""
rb_movers = []
# ADD CHECK: these particles are not already part of some RB or SRB
# First, is this already a rigid body?
if type(rigid_parts) is IMP.core.RigidBody:
rb = rigid_parts
if name is not None:
name = rb.get_name()
else:
### Otherwise, setup RB
hiers = IMP.pmi.tools.input_adaptor(rigid_parts,
resolution,
flatten=True)
if not hiers:
print(
"WARNING: No hierarchies were passed to create_rigid_body()"
)
return []
rb = IMP.atom.create_rigid_body(hiers)
self.rigid_bodies.append(rb)
rb.set_coordinates_are_optimized(True)
rb_mover = IMP.core.RigidBodyMover(rb, max_trans, max_rot)
if name is not None:
rb.set_name(name)
rb_mover.set_name(name)
rb_movers.append(rb_mover)
### setup nonrigid parts
if nonrigid_parts:
nr_hiers = IMP.pmi.tools.input_adaptor(nonrigid_parts,
resolution,
flatten=True)
if nr_hiers:
floatkeys = [IMP.FloatKey(4), IMP.FloatKey(5), IMP.FloatKey(6)]
rb_idxs = set(rb.get_member_indexes())
for h in nr_hiers:
self.flexible_beads.append(h)
p = h.get_particle()
if not p.get_index() in rb_idxs:
raise Exception(
"You tried to create nonrigid members from "
"particles that aren't in the RigidBody!")
rb.set_is_rigid_member(p.get_index(), False)
for fk in floatkeys:
p.set_is_optimized(fk, True)
rb_movers.append(
IMP.core.BallMover([p], IMP.FloatKeys(floatkeys),
nonrigid_max_trans))
self.movers += rb_movers # probably need to store more info
return rb_movers, rb
def test_import_module(self):
"""Test CommandDispatcher.import_module()"""
c = IMP.CommandDispatcher("short", "long", "TestModule")
self.assertEqual(id(c.import_module()), id(TestModule))
self.assertEqual(id(c.import_module('submodule')),
id(TestModule.submodule))
def test_input_adaptor_pmi(self):
"""Test that input adaptor correctly performs selection"""
mdl = IMP.Model()
s = IMP.pmi.topology.System(mdl)
seqs = IMP.pmi.topology.Sequences(
self.get_input_file_name('seqs.fasta'))
st1 = s.create_state()
m1 = st1.create_molecule("Prot1", sequence=seqs["Protein_1"])
m2 = st1.create_molecule("Prot2", sequence=seqs["Protein_2"])
m3 = st1.create_molecule("Prot3", sequence=seqs["Protein_3"])
a1 = m1.add_structure(self.get_input_file_name('prot.pdb'),
chain_id='A',
res_range=(55, 63),
offset=-54)
a2 = m2.add_structure(self.get_input_file_name('prot.pdb'),
chain_id='B',
res_range=(180, 192),
offset=-179)
a3 = m3.add_structure(self.get_input_file_name('prot.pdb'),
chain_id='G',
res_range=(55, 63),
offset=-54)
m1.add_representation(a1, resolutions=[0, 1])
m1.add_representation(m1.get_non_atomic_residues(), resolutions=[1])
m2.add_representation(a2, resolutions=[0, 1]) # m2 only has atoms
m3.add_representation(a3, resolutions=[1, 10])
m3.add_representation(m3.get_non_atomic_residues(),
resolutions=[1],
setup_particles_as_densities=True)
hier = s.build()
densities = [r.get_hierarchy() for r in m3.get_non_atomic_residues()]
#set up GMM particles
gemt = IMP.pmi.restraints.em.GaussianEMRestraint(
densities,
self.get_input_file_name('prot_gmm.txt'),
target_is_rigid_body=True)
gmm_hier = gemt.get_density_as_hierarchy()
test0 = IMP.pmi.tools.input_adaptor(gmm_hier)
self.assertEqual(test0, [IMP.atom.get_leaves(gmm_hier)])
# get one resolution
test1 = IMP.pmi.tools.input_adaptor(m1, pmi_resolution=0)
self.assertEqual(test1, [
IMP.atom.Selection(m1.get_hierarchy(),
resolution=0).get_selected_particles()
])
# get all resolutions
test1all = IMP.pmi.tools.input_adaptor(m1, pmi_resolution='all')
compare1all = set(
IMP.atom.Selection(m1.get_hierarchy(),
resolution=0).get_selected_particles() +
IMP.atom.Selection(m1.get_hierarchy(),
resolution=1).get_selected_particles())
self.assertEqual(set(test1all[0]), compare1all)
# list of set of TempResidue
test3 = IMP.pmi.tools.input_adaptor([m1[0:3], m2[:], m3[0:1]],
pmi_resolution=1)
compare3 = [
IMP.atom.Selection(m1.get_hierarchy(),
residue_indexes=[1, 2, 3],
resolution=1).get_selected_particles(),
IMP.atom.Selection(m2.get_hierarchy(),
resolution=1).get_selected_particles(),
IMP.atom.Selection(m3.get_hierarchy(),
residue_index=1,
resolution=1).get_selected_particles()
]
self.assertEqual([set(l) for l in test3], [set(l) for l in compare3])
# check robustness and consistency TempResidue + Hierarchy
test4 = IMP.pmi.tools.input_adaptor([m1[0:3], m2[:], m3[0:1]],
flatten=True,
pmi_resolution=1)
compare4 = IMP.pmi.tools.input_adaptor(compare3,
pmi_resolution=1,
flatten=True)
compare5 = IMP.pmi.tools.input_adaptor(compare3, flatten=True)
compare6 = IMP.pmi.tools.input_adaptor(compare3,
pmi_resolution='all',
flatten=True)
self.assertEqual(test4, compare4)
self.assertEqual(test4, compare5)
self.assertEqual(test4, compare6)
# check input is list or list of lists
test5 = IMP.pmi.tools.input_adaptor([m1, m2, m3], pmi_resolution=1)
test6 = IMP.pmi.tools.input_adaptor([[m1, m2], [m3]], pmi_resolution=1)
self.assertEqual(test5, test6)
# test input particles and input hierarchies
compare7 = [
IMP.atom.Hierarchy(p) for sublist in compare3 for p in sublist
]
test7 = IMP.pmi.tools.input_adaptor(compare7,
flatten=True,
pmi_resolution=1)
compare8 = [p for sublist in compare3 for p in sublist]
test8 = IMP.pmi.tools.input_adaptor(compare8,
flatten=True,
pmi_resolution=1)
self.assertEqual(test7, test8)
# raises if passing an uneven list
with self.assertRaises(Exception):
IMP.pmi.tools.input_adaptor([[m1, m2], m3], pmi_resolution=1)
#raises if passing mixed lists
with self.assertRaises(Exception):
IMP.pmi.tools.input_adaptor([m1, s, m3], pmi_resolution=1)
# compare hierarchies and pmi molecules:
m1s_pmi = IMP.pmi.tools.input_adaptor(m1, pmi_resolution=1)
m1s_hiers = IMP.pmi.tools.input_adaptor(m1.hier, pmi_resolution=1)
self.assertEqual([set(l) for l in m1s_pmi],
[set(l) for l in m1s_hiers])
m1s_pmi = IMP.pmi.tools.input_adaptor(m1, pmi_resolution=10)
m1s_hiers = IMP.pmi.tools.input_adaptor(m1.hier, pmi_resolution=10)
self.assertEqual([set(l) for l in m1s_pmi],
[set(l) for l in m1s_hiers])
m1s_pmi = IMP.pmi.tools.input_adaptor(m1, pmi_resolution='all')
m1s_hiers = IMP.pmi.tools.input_adaptor(m1.hier, pmi_resolution='all')
self.assertEqual([set(l) for l in m1s_pmi],
[set(l) for l in m1s_hiers])
# compare hierarchies and pmi states:
st1s_pmi = IMP.pmi.tools.input_adaptor(st1,
pmi_resolution=1,
flatten=True)
st1s_hiers = IMP.pmi.tools.input_adaptor(st1.hier,
pmi_resolution=1,
flatten=True)
self.assertEqual(st1s_pmi, st1s_hiers)
st1s_pmi = IMP.pmi.tools.input_adaptor(st1,
pmi_resolution=10,
flatten=True)
st1s_hiers = IMP.pmi.tools.input_adaptor(st1.hier,
pmi_resolution=10,
flatten=True)
self.assertEqual(st1s_pmi, st1s_hiers)
st1s_pmi = IMP.pmi.tools.input_adaptor(st1,
pmi_resolution='all',
flatten=True)
st1s_hiers = IMP.pmi.tools.input_adaptor(st1.hier,
pmi_resolution='all',
flatten=True)
self.assertEqual(st1s_pmi, st1s_hiers)
# compare hierarchies and pmi system:
sys_pmi = IMP.pmi.tools.input_adaptor(s,
pmi_resolution=1,
flatten=True)
sys_hiers = IMP.pmi.tools.input_adaptor(s.hier,
pmi_resolution=1,
flatten=True)
self.assertEqual(sys_pmi, sys_hiers)
sys_pmi = IMP.pmi.tools.input_adaptor(s,
pmi_resolution=10,
flatten=True)
sys_hiers = IMP.pmi.tools.input_adaptor(s.hier,
pmi_resolution=10,
flatten=True)
self.assertEqual(sys_pmi, sys_hiers)
sys_pmi = IMP.pmi.tools.input_adaptor(s,
pmi_resolution='all',
flatten=True)
sys_hiers = IMP.pmi.tools.input_adaptor(s.hier,
pmi_resolution='all',
flatten=True)
self.assertEqual(sys_pmi, sys_hiers)
# nothing changes to hierarchy
p = IMP.Particle(mdl)
h = IMP.atom.Hierarchy.setup_particle(p)
IMP.atom.Mass.setup_particle(p, 1.0)
xyzr = IMP.core.XYZR.setup_particle(p)
xyzr.set_coordinates((0, 0, 0))
xyzr.set_radius(1.0)
tH = [h]
testH = IMP.pmi.tools.input_adaptor(tH)
self.assertEqual(testH, [tH])
# check passing system,state
testSystem = [
set(l) for l in IMP.pmi.tools.input_adaptor(s, pmi_resolution=0)
]
testState = [
set(l) for l in IMP.pmi.tools.input_adaptor(st1, pmi_resolution=0)
]
compareAll = [
set(
IMP.atom.Selection(m.get_hierarchy(),
resolution=0).get_selected_particles())
for m in [m1, m2, m3]
]
# get_molecules() returns a dict, so the order of testSystem
# and testState is not guaranteed
self.assertEqualUnordered(testSystem, compareAll)
self.assertEqualUnordered(testState, compareAll)
def test_show_command_help_help(self):
"""Test CommandDispatcher show help command help"""
sys.argv = ['testprog', 'help', 'help']
c = IMP.CommandDispatcher("short", "long", "TestModule")
c.main()
self.assert_help_out_ok()
# addition, show how to visualize restraints and visualize the
# rejected conformations. Both are useful things to do when trying to
# figure out why optimization is not converging.
from __future__ import print_function
import IMP
import IMP.atom
import IMP.container
import IMP.display
import IMP.statistics
import IMP.example
import os
import sys
# not finished
IMP.add_bool_flag("run", "Whether to run the program")
# parse command line arguments so, eg profiling can be used
IMP.setup_from_argv(sys.argv, "Nup84 example")
if IMP.get_bool_flag("run") != "yes":
exit(0)
# First we define some basic parameters for the modeling effort
# the spring constant to use, it doesn't really matter
k = 10
# the target resolution for the representation
resolution = 100
# the box to perform everything in, make it flat as it is a 2D structure
bb = IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(-300, -300, -50),
def unprotected_evaluate(self, da):
score = 0
for i in range(1, len(self.ps)):
p0 = self.ps[i - 1]
p1 = self.ps[i]
if p0.get_value(k) > p1.get_value(k):
diff = (p0.get_value(k) - p1.get_value(k))
score = score + diff
p0.add_to_derivative(k, -1, da)
p1.add_to_derivative(k, 1, da)
else:
if IMP.get_log_level() >= IMP.base.TERSE:
print p0.get_name(), "and", p1.get_name(), " are ok"
return score
def do_get_inputs(self):
return self.ps
# some code to create and evaluate it
k = IMP.FloatKey("a key")
m = IMP.kernel.Model()
ps = []
for i in range(0, 10):
p = IMP.kernel.Particle(m)
p.add_attribute(k, i)
ps.append(p)
r = MyRestraint(m, ps, k)
# IMP.base.set_log_level(IMP.base.TERSE)
print r.evaluate(True)
def test_init(self):
"""Test CommandDispatcher init"""
sys.argv = ['/foo/bar/testprogname', 'arg1']
c = IMP.CommandDispatcher("short", "long", "TestModule")
self.assertEqual(c._progname, 'testprogname')
def tearDown(self):
# Restore original check level
IMP.set_check_level(self.__check_level)
# Clean up any temporary files
if hasattr(self, '_tmpdir'):
del self._tmpdir
def test_relative_position_mover(self, ):
""" Test the RelativePositionMover """
log.info("test RelativePositionMover")
fn_rec1 = self.get_input_file_name("1suvA_xlinked.pdb")
fn_rec2 = self.get_input_file_name("1suvC_xlinked.pdb")
fn_lig = self.get_input_file_name("1suvE_xlinked.pdb")
fn_tr1 = \
self.get_input_file_name("transforms-1suvA-1suvE_reduced.txt")
fn_tr2 = \
self.get_input_file_name("transforms-1suvC-1suvE_filtered.txt")
m = IMP.Model()
sel = atom.ATOMPDBSelector()
h_rec1 = atom.read_pdb(fn_rec1, m, sel)
rb_rec1 = atom.create_rigid_body(h_rec1)
rec1_coords = [
core.XYZ(l).get_coordinates() for l in atom.get_leaves(h_rec1)
]
h_rec2 = atom.read_pdb(fn_rec2, m, sel)
rb_rec2 = atom.create_rigid_body(h_rec2)
rec2_coords = [
core.XYZ(l).get_coordinates() for l in atom.get_leaves(h_rec2)
]
h_ligand = atom.read_pdb(fn_lig, m, sel)
rb_lig = atom.create_rigid_body(h_ligand)
Ts = get_relative_transforms(fn_tr1)
Tis1 = []
for i, T in enumerate(Ts):
V = get_internal_transform3(T, rb_rec1, rb_lig)
Tis1.append(V)
docked_refs1 = get_docked_reference_frames(Ts, rb_lig)
Ts = get_relative_transforms(fn_tr2)
Tis2 = []
for i, T in enumerate(Ts):
V = get_internal_transform3(T, rb_rec2, rb_lig)
Tis2.append(V)
docked_refs2 = get_docked_reference_frames(Ts, rb_lig)
mv = em2d.RelativePositionMover(rb_lig, 10, 20)
mv.add_internal_transformations(rb_rec1, Tis1)
mv.add_internal_transformations(rb_rec2, Tis2)
for i in range(2):
# prob_random = 0
ref_before = rb_lig.get_reference_frame()
ps = mv.propose() # _move(prob_random)
ref_after = rb_lig.get_reference_frame()
found = False
current_coords = [
core.XYZ(l).get_coordinates()
for l in atom.get_leaves(h_ligand)
]
# check all possible reference frames where the ligand could be
for r in itertools.chain(docked_refs1, docked_refs2):
rb_lig.set_reference_frame(r)
docked_coords = [
core.XYZ(l).get_coordinates()
for l in atom.get_leaves(h_ligand)
]
rmsd = alg.get_rmsd(current_coords, docked_coords)
if rmsd < 0.1:
found = True
self.assertTrue(found,
msg="the proposed move is not "
"in the relative solutions")
mv.accept()
def create_particle(self, m):
p = IMP.kernel.Particle(m)
p.add_attribute(IMP.FloatKey("thekey"), float(1))
return p
def assertRaisesInternalException(self, c, *args, **keys):
"""Assert that the given callable object raises InternalException.
This differs from unittest's assertRaises in that the test
is skipped in fast mode (where internal checks are turned off)."""
if IMP.get_check_level() >= IMP.USAGE_AND_INTERNAL:
return self.assertRaises(IMP.InternalException, c, *args, **keys)
