def _make_stuff(self):
m = IMP.Model()
rs = IMP.RestraintSet(m, .5, "RS")
r0 = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r0)
r1 = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r1)
r2 = IMP._ConstRestraint(m, [], 1)
return (m, rs, r0, r1, r2)
def _make_stuff(self):
m= IMP.Model()
rs= IMP.RestraintSet(.5)
r0= IMP._ConstRestraint(1)
rs.add_restraint(r0)
m.add_restraint(rs)
r1= IMP._ConstRestraint(1)
rs.add_restraint(r1)
r2= IMP._ConstRestraint(1)
m.add_restraint(r2)
return (m, rs, r0, r1, r2)
def test_add_restraint(self):
"""Test add_restraint_to_model()"""
m = IMP.Model()
r1 = IMP._ConstRestraint(m, [], 1)
IMP.pmi.tools.add_restraint_to_model(m, r1, add_to_rmf=False)
r2 = IMP._ConstRestraint(m, [], 1)
IMP.pmi.tools.add_restraint_to_model(m, r2, add_to_rmf=True)
rs = IMP.pmi.tools.get_restraint_set(m, rmf=False)
self.assertEqual(rs.get_number_of_restraints(), 2)
rs = IMP.pmi.tools.get_restraint_set(m, rmf=True)
self.assertEqual(rs.get_number_of_restraints(), 1)
def test_add_restraint(self):
"""Test add_restraint_to_model()"""
m = IMP.Model()
r1 = IMP._ConstRestraint(m, [], 1)
IMP.pmi.tools.add_restraint_to_model(m, r1, add_to_rmf=False)
r2 = IMP._ConstRestraint(m, [], 1)
IMP.pmi.tools.add_restraint_to_model(m, r2, add_to_rmf=True)
rs = IMP.pmi.tools.get_restraint_set(m, rmf=False)
self.assertEqual(rs.get_number_of_restraints(), 2)
rs = IMP.pmi.tools.get_restraint_set(m, rmf=True)
self.assertEqual(rs.get_number_of_restraints(), 1)
def test_model_objects(self):
"""Test that model objects can get passed from python"""
m = IMP.Model("model objets")
r = IMP._ConstRestraint(m, [], 1)
p = IMP.Particle(m)
self.assertEqual([p], IMP._pass_model_objects([p]))
self.assertEqual([r, p], IMP._pass_model_objects([r, p]))
def test_score_state_show(self):
"""Test scoring function linkage"""
m = IMP.Model("scoring function linkage")
ps = [IMP.Particle(m) for i in range(0, 10)]
r = IMP._ConstRestraint(1, ps)
r.create_scoring_function()
self.assertEqual(r.evaluate(False), 1)
def test_global_min3(self):
"""Test sampling with edge scores"""
m= IMP.Model()
m.set_log_level(IMP.SILENT)
ps=[]
for i in range(0,3):
p= IMP.Particle(m)
d= IMP.core.XYZ.setup_particle(p)
ps.append(p)
pts=[IMP.algebra.Vector3D(0,0,0),
IMP.algebra.Vector3D(1,0,0),
IMP.algebra.Vector3D(2,0,0),
IMP.algebra.Vector3D(3,0,0)]
particle_state= IMP.domino.XYZStates(pts)
pst= IMP.domino.ParticleStatesTable()
for p in ps:
pst.set_particle_states(p, particle_state)
m.add_restraint(IMP._ConstRestraint(1, [p]))
m.add_restraint(IMP.core.DistanceRestraint(IMP.core.Harmonic(1,1), ps[0], ps[1]))
m.add_restraint(IMP.core.DistanceRestraint(IMP.core.Harmonic(1,1), ps[1], ps[2]))
m.set_maximum_score(3.1)
sampler= IMP.domino.DominoSampler(m, pst)
sampler.set_log_level(IMP.VERBOSE)
cs= sampler.get_sample()
self.assertGreater(cs.get_number_of_configurations(), 0)
for i in range(0, cs.get_number_of_configurations()):
cs.load_configuration(i)
self.assertLess((IMP.core.get_distance(IMP.core.XYZ(ps[0]),IMP.core.XYZ(ps[1]))-1)**2, .1)
self.assertLess((IMP.core.get_distance(IMP.core.XYZ(ps[1]),IMP.core.XYZ(ps[2]))-1)**2, .1)
def setup(self):
"""Build a set of test particles"""
IMP.test.TestCase.setUp(self)
model = IMP.Model("particles model")
particles = []
# create particles 0 - 11
for i in range(0, 12):
particles.append(
self.create_point_particle(model, i * 2, i * 3, i * 4))
p1 = particles[i]
p1.add_attribute(radkey, 1.5 * i, False)
p1.add_attribute(idkey, i)
p1.add_attribute(IMP.IntKey("six"), 6)
p1.add_attribute(IMP.StringKey("id_str"), "name_" + str(i))
p1.add_attribute(IMP.StringKey("six"), "b:0110")
# add additional attributes to particle 11
for i in range(0, 6):
p1.add_attribute(IMP.FloatKey("attr_" + str(i)), 3.5 * i, False)
# clear derivatives
print(model.get_ref_count())
r = IMP._ConstRestraint(1, particles)
r.evaluate(True)
print(model.get_ref_count())
return (model, particles)
def test_model_objects(self):
"""Test that model objects can get passed from python"""
m = IMP.Model("model objets")
r = IMP._ConstRestraint(m, [], 1)
p = IMP.Particle(m)
self.assertEqual([p], IMP._pass_model_objects([p]))
self.assertEqual([r, p], IMP._pass_model_objects([r, p]))
def setup(self):
"""Build a set of test particles"""
IMP.test.TestCase.setUp(self)
model = IMP.Model("particles model")
particles = []
# create particles 0 - 11
for i in range(0, 12):
particles.append(self.create_point_particle(model,
i * 2, i * 3, i * 4))
p1 = particles[i]
p1.add_attribute(radkey, 1.5 * i, False)
p1.add_attribute(idkey, i)
p1.add_attribute(IMP.IntKey("six"), 6)
p1.add_attribute(IMP.StringKey("id_str"), "name_" + str(i))
p1.add_attribute(IMP.StringKey("six"), "b:0110")
# add additional attributes to particle 11
for i in range(0, 6):
p1.add_attribute(IMP.FloatKey("attr_" + str(i)), 3.5 * i, False)
# clear derivatives
print(model.get_ref_count())
r = IMP._ConstRestraint(1, particles)
r.evaluate(True)
print(model.get_ref_count())
return (model, particles)
def test_score_state_show(self):
"""Test scoring function linkage"""
m = IMP.Model("scoring function linkage")
ps = [IMP.Particle(m) for i in range(0, 10)]
r = IMP._ConstRestraint(1, ps)
r.create_scoring_function()
self.assertEqual(r.evaluate(False), 1)
def test_restraint_score(self):
"""Test restraint score log"""
m = IMP.Model()
r0 = IMP._ConstRestraint(m, [], 1)
r0.set_name("r0")
r1 = IMP._ConstRestraint(m, [], 2)
r1.set_name("r1")
sf = IMP.core.RestraintsScoringFunction([r0, r1])
nm = self.get_tmp_file_name("score_log.csv")
l = IMP.core.WriteRestraintScoresOptimizerState([r0, r1], nm)
sf.evaluate(True)
l.update()
l.update()
l.update()
del l
txt = open(nm, "r").read()
print(txt)
def test_restraint_score(self):
"""Test restraint score log"""
m = IMP.Model()
r0 = IMP._ConstRestraint(m, [], 1)
r0.set_name("r0")
r1 = IMP._ConstRestraint(m, [], 2)
r1.set_name("r1")
sf = IMP.core.RestraintsScoringFunction([r0, r1])
nm = self.get_tmp_file_name("score_log.csv")
l = IMP.core.WriteRestraintScoresOptimizerState([r0, r1], nm)
sf.evaluate(True)
l.update()
l.update()
l.update()
del l
txt = open(nm, "r").read()
print(txt)
def test_delete_model_accessor_restraint(self):
"Python restraints from vector accessors should survive model deletion"
IMP.set_log_level(IMP.MEMORY)
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("test model")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
print("adding")
rs.add_restraint(r)
print(r)
print(r.__del__)
# 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 restraints")
ps = rs.get_restraints()
print("getting restraint")
p = ps[0]
print(sys.getrefcount(p), len(ps))
print(p)
# r, m, p/ps
self.assertEqual(p.get_ref_count(), 3)
print("deleting ps")
del ps
# r, m, p
self.assertEqual(p.get_ref_count(), 3)
print("getting it again")
rp = rs.get_restraint(0)
print("check")
# Python reference p, m, r, rp
self.assertEqual(p.get_ref_count(), 4)
print(p)
print(p.thisown)
print(dir(p))
print(sys.getrefcount(p))
print("deleting p")
#del p
# p.__del__
print(p.__del__)
del p
# Python reference m, r, rp
print("checking p")
self.assertEqual(r.get_ref_count(), 3)
print('deleting rp')
del rp
# Python reference m, r
self.assertEqual(r.get_ref_count(), 2)
print("deleting model")
del m, rs
refcnt.assert_number(1)
# Now only the Python reference p should survive
self.assertEqual(r.get_ref_count(), 1)
print('deleting r')
print(r)
del r
refcnt.assert_number(0)
def test_delete_model_accessor_restraint(self):
"Python restraints from vector accessors should survive model deletion"
IMP.set_log_level(IMP.MEMORY)
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("test model")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
print("adding")
rs.add_restraint(r)
print(r)
print(r.__del__)
# 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 restraints")
ps = rs.get_restraints()
print("getting restraint")
p = ps[0]
print(sys.getrefcount(p), len(ps))
print(p)
# r, m, p/ps
self.assertEqual(p.get_ref_count(), 3)
print("deleting ps")
del ps
# r, m, p
self.assertEqual(p.get_ref_count(), 3)
print("getting it again")
rp = rs.get_restraint(0)
print("check")
# Python reference p, m, r, rp
self.assertEqual(p.get_ref_count(), 4)
print(p)
print(p.thisown)
print(dir(p))
print(sys.getrefcount(p))
print("deleting p")
#del p
# p.__del__
print(p.__del__)
del p
# Python reference m, r, rp
print("checking p")
self.assertEqual(r.get_ref_count(), 3)
print('deleting rp')
del rp
# Python reference m, r
self.assertEqual(r.get_ref_count(), 2)
print("deleting model")
del m, rs
refcnt.assert_number(1)
# Now only the Python reference p should survive
self.assertEqual(r.get_ref_count(), 1)
print('deleting r')
print(r)
del r
refcnt.assert_number(0)
def test_restraint_score(self):
"""Test restraint score log"""
m = IMP.Model()
r0 = IMP._ConstRestraint(1)
r0.set_name("r0")
r1 = IMP._ConstRestraint(2)
r1.set_name("r1")
m.add_restraint(r0)
m.add_restraint(r1)
nm = self.get_tmp_file_name("score_log.csv")
l = IMP.core.WriteRestraintScoresOptimizerState([r0, r1], nm)
m.evaluate(True)
l.update()
l.update()
l.update()
del l
txt = open(nm, "r").read()
print txt
def test_cast(self):
"""Test that casting objects works"""
m = IMP.Model("object cast")
r = IMP._ConstRestraint(1)
m.add_restraint(r)
rb = m.get_restraints()[0]
# print rb.get_value()
rc = IMP._ConstRestraint.get_from(rb)
print rc.get_value()
def test_overload(self):
"""Checking that overloading works"""
m = IMP.Model("overloading")
p = IMP.Particle(m)
r = IMP._ConstRestraint(m, [], 1)
pi = IMP._test_overload([p])
ri = IMP._test_overload([r])
self.assertEqual(pi, 0)
self.assertEqual(ri, 1)
def test_printing(self):
"""Test ref counting works with restraints and scoring functions"""
m = IMP.Model()
# make sure that sf keeps the restraint alive
sf = IMP._ConstRestraint(m, [], 1).create_scoring_function()
IMP.set_log_level(IMP.MEMORY)
# trigger cleanup
m.update()
sf.evaluate(False)
def test_overload(self):
"""Checking that overloading works"""
m = IMP.Model("overloading")
p = IMP.Particle(m)
r = IMP._ConstRestraint(m, [], 1)
pi = IMP._test_overload([p])
ri = IMP._test_overload([r])
self.assertEqual(pi, 0)
self.assertEqual(ri, 1)
def test_restraint_cast(self):
"""Test that restraints can be cast"""
m = IMP.Model("model objets")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
rb = rs.get_restraint(0)
rbc = IMP._ConstRestraint.get_from(rb)
self.assertEqual(rbc, rb)
def test_restraint_cast(self):
"""Test that restraints can be cast"""
m = IMP.Model("model objets")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
rb = rs.get_restraint(0)
rbc = IMP._ConstRestraint.get_from(rb)
self.assertEqual(rbc, rb)
def test_printing(self):
"""Test ref counting works with restraints and scoring functions"""
m = IMP.Model()
# make sure that sf keeps the restraint alive
sf = IMP._ConstRestraint(m, [], 1).create_scoring_function()
IMP.set_log_level(IMP.MEMORY)
# trigger cleanup
m.update()
sf.evaluate(False)
def test_cast(self):
"""Test that casting objects works"""
m = IMP.Model("object cast")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
rb = rs.get_restraint(0)
# print rb.get_value()
rc = IMP._ConstRestraint.get_from(rb)
print(rc.get_value())
def test_cast(self):
"""Test that casting objects works"""
m = IMP.Model("object cast")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
rb = rs.get_restraint(0)
# print rb.get_value()
rc = IMP._ConstRestraint.get_from(rb)
print(rc.get_value())
def test_symmetry(self):
"""Test the transform pair score basics"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
p0 = m.add_particle("p0")
d0 = IMP.core.XYZ.setup_particle(m, p0)
p1 = m.add_particle("p1")
d1 = IMP.core.XYZ.setup_particle(m, p1)
t = IMP.algebra.Vector3D(0, 1, 0)
tr = IMP.algebra.Transformation3D(
IMP.algebra.get_identity_rotation_3d(),
t)
tps = IMP.core.TransformedDistancePairScore(
IMP.core.Harmonic(0, 1), tr)
tps.set_was_used(True)
d0.set_coordinates(IMP.algebra.Vector3D(2, 3, 4))
d1.set_coordinates(IMP.algebra.Vector3D(2, 2, 4))
self.assertEqual(tps.evaluate_index(m, (p0, p1), None), 0)
self.assertNotEqual(tps.evaluate_index(m, (p1, p0), None), 0)
print("test rotation")
rot = IMP.algebra.get_rotation_from_matrix(0, 0, -1,
0, 1, 0,
1, 0, 0)
tr = IMP.algebra.Transformation3D(rot, t)
tps.set_transformation(tr)
d1.set_coordinates(IMP.algebra.Vector3D(4, 2, -2))
self.assertAlmostEqual(tps.evaluate_index(m, (p0, p1), None),
0, delta=.01)
self.assertNotEqual(tps.evaluate_index(m, (p1, p0), None), 0)
t = IMP.algebra.Vector3D(0, 0, 0)
rot = IMP.algebra.get_rotation_from_matrix(0, -1, 0,
1, 0, 0,
0, 0, 1)
tps.set_transformation(IMP.algebra.Transformation3D(rot, t))
d0.set_coordinates(IMP.algebra.Vector3D(0, 1, 0))
d1.set_coordinates(IMP.algebra.Vector3D(1, 1, 0))
# clear derivs
print("test derivs")
const_restraint = IMP._ConstRestraint(m, [p0, p1], 0)
const_restraint.evaluate(True)
tps.evaluate_index(m, (p0, p1), IMP.DerivativeAccumulator(1))
print(d0.get_derivative(0))
print(d0.get_derivative(1))
print(d0.get_derivative(2))
print(d1.get_derivative(0))
print(d1.get_derivative(1))
print(d1.get_derivative(2))
self.assertGreater(d0.get_derivative(0), 0)
self.assertAlmostEqual(d0.get_derivative(1), 0, delta=.1)
self.assertAlmostEqual(d0.get_derivative(2), 0, delta=.1)
self.assertGreater(d1.get_derivative(1), 0)
self.assertAlmostEqual(d1.get_derivative(0), 0, delta=.1)
self.assertAlmostEqual(d1.get_derivative(2), 0, delta=.1)
def test_weights(self):
"""Test that restraints decompose ok"""
m = IMP.Model()
p = IMP.Particle(m)
r = IMP._ConstRestraint(1, [p])
rd = r.create_decomposition()
self.assertEqual(r.evaluate(False), rd.evaluate(False))
ra = IMP.get_restraints([r])
rda = IMP.get_restraints([rd])
sf = IMP.core.RestraintsScoringFunction(ra)
sfda = IMP.core.RestraintsScoringFunction(rda)
self.assertEqual(sf.evaluate(False), sfda.evaluate(False))
def _create_stuff(self):
m = IMP.Model()
ps = [IMP.Particle(m) for i in range(0, 10)]
r = IMP._ConstRestraint(1, ps)
r.set_name("const restraint")
pst = IMP.domino.ParticleStatesTable()
ik = IMP.IntKey("key")
for p in ps:
p.add_attribute(ik, 0)
pst.set_particle_states(p, IMP.domino.IndexStates(4, ik))
cache = IMP.domino.RestraintCache(pst, 4)
return (m, ps, r, pst, ik, cache)
def _create_stuff(self):
m = IMP.Model()
ps = [IMP.Particle(m) for i in range(0, 10)]
r = IMP._ConstRestraint(1, ps)
r.set_name("const restraint")
pst = IMP.domino.ParticleStatesTable()
ik = IMP.IntKey("key")
for p in ps:
p.add_attribute(ik, 0)
pst.set_particle_states(p, IMP.domino.IndexStates(4, ik))
cache = IMP.domino.RestraintCache(pst, 4)
return (m, ps, r, pst, ik, cache)
def test_symmetry(self):
"""Test the transform pair score basics"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
p0 = m.add_particle("p0")
d0 = IMP.core.XYZ.setup_particle(m, p0)
p1 = m.add_particle("p1")
d1 = IMP.core.XYZ.setup_particle(m, p1)
t = IMP.algebra.Vector3D(0, 1, 0)
tr = IMP.algebra.Transformation3D(
IMP.algebra.get_identity_rotation_3d(), t)
tps = IMP.core.TransformedDistancePairScore(IMP.core.Harmonic(0, 1),
tr)
tps.set_was_used(True)
d0.set_coordinates(IMP.algebra.Vector3D(2, 3, 4))
d1.set_coordinates(IMP.algebra.Vector3D(2, 2, 4))
self.assertEqual(tps.evaluate_index(m, (p0, p1), None), 0)
self.assertNotEqual(tps.evaluate_index(m, (p1, p0), None), 0)
print("test rotation")
rot = IMP.algebra.get_rotation_from_matrix(0, 0, -1, 0, 1, 0, 1, 0, 0)
tr = IMP.algebra.Transformation3D(rot, t)
tps.set_transformation(tr)
d1.set_coordinates(IMP.algebra.Vector3D(4, 2, -2))
self.assertAlmostEqual(tps.evaluate_index(m, (p0, p1), None),
0,
delta=.01)
self.assertNotEqual(tps.evaluate_index(m, (p1, p0), None), 0)
t = IMP.algebra.Vector3D(0, 0, 0)
rot = IMP.algebra.get_rotation_from_matrix(0, -1, 0, 1, 0, 0, 0, 0, 1)
tps.set_transformation(IMP.algebra.Transformation3D(rot, t))
d0.set_coordinates(IMP.algebra.Vector3D(0, 1, 0))
d1.set_coordinates(IMP.algebra.Vector3D(1, 1, 0))
# clear derivs
print("test derivs")
const_restraint = IMP._ConstRestraint(m, [p0, p1], 0)
const_restraint.evaluate(True)
tps.evaluate_index(m, (p0, p1), IMP.DerivativeAccumulator(1))
print(d0.get_derivative(0))
print(d0.get_derivative(1))
print(d0.get_derivative(2))
print(d1.get_derivative(0))
print(d1.get_derivative(1))
print(d1.get_derivative(2))
self.assertGreater(d0.get_derivative(0), 0)
self.assertAlmostEqual(d0.get_derivative(1), 0, delta=.1)
self.assertAlmostEqual(d0.get_derivative(2), 0, delta=.1)
self.assertGreater(d1.get_derivative(1), 0)
self.assertAlmostEqual(d1.get_derivative(0), 0, delta=.1)
self.assertAlmostEqual(d1.get_derivative(2), 0, delta=.1)
def test_reweighting(self):
"""Test scoring function reweighting"""
m = IMP.Model("scoring function linkage")
ps = [IMP.Particle(m) for i in range(0, 10)]
r = IMP._ConstRestraint(1, ps)
rs = IMP.RestraintSet(m, 1.0, "rs")
rs.add_restraint(r)
rsf = rs.create_scoring_function()
self.assertEqual(rsf.evaluate(False), 1)
r.set_weight(0)
self.assertEqual(rsf.evaluate(False), 0)
r.set_weight(1)
rs.set_weight(0)
self.assertEqual(rsf.evaluate(False), 0)
def test_reweighting(self):
"""Test scoring function reweighting"""
m = IMP.Model("scoring function linkage")
ps = [IMP.Particle(m) for i in range(0, 10)]
r = IMP._ConstRestraint(1, ps)
rs = IMP.RestraintSet(m, 1.0, "rs")
rs.add_restraint(r)
rsf = rs.create_scoring_function()
self.assertEqual(rsf.evaluate(False), 1)
r.set_weight(0)
self.assertEqual(rsf.evaluate(False), 0)
r.set_weight(1)
rs.set_weight(0)
self.assertEqual(rsf.evaluate(False), 0)
def test_global_min3(self):
"""Test caching sampling with edge scores"""
m = IMP.Model()
m.set_log_level(IMP.SILENT)
ps = []
ds = []
for i in range(0, 3):
p = IMP.Particle(m)
d = IMP.core.XYZ.setup_particle(p)
print(d)
ds.append(d)
ps.append(p)
pts = [
IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(1, 0, 0),
IMP.algebra.Vector3D(2, 0, 0),
IMP.algebra.Vector3D(3, 0, 0)
]
particle_state = IMP.domino.XYZStates(pts)
pst = IMP.domino.ParticleStatesTable()
r = IMP.RestraintSet(m)
for p in ps:
pst.set_particle_states(p, particle_state)
r.add_restraint(IMP._ConstRestraint(1, [p]))
sst = IMP.domino.BranchAndBoundAssignmentsTable(pst, [])
r.add_restraint(
IMP.core.DistanceRestraint(m, IMP.core.Harmonic(1, 1), ps[0],
ps[1]))
r.add_restraint(
IMP.core.DistanceRestraint(m, IMP.core.Harmonic(1, 1), ps[1],
ps[2]))
#sevt= IMP.domino.ModelSubsetEvaluatorTable(m, pst)
sampler = IMP.domino.DominoSampler(m, pst)
sampler.set_restraints(r)
# sampler.set_subset_evaluator_table(sevt);
sampler.set_log_level(IMP.VERBOSE)
# sampler.set_assignments_table(sst)
r.set_maximum_score(3.1)
print("getting sample")
cs = sampler.create_sample()
print("done")
self.assertGreater(cs.get_number_of_configurations(), 0)
for i in range(0, cs.get_number_of_configurations()):
print("loading ", i)
cs.load_configuration(i)
print("testing")
dist = IMP.core.get_distance(ds[0], ds[1])
print(dist)
self.assertLess((dist - 1)**2, .1)
self.assertLess((IMP.core.get_distance(ds[1], ds[2]) - 1)**2, .1)
def test_rot_nrb(self):
"""Check hidden rigid body correlation time"""
print("TEST_ROT_NRB")
m= IMP.Model()
p= IMP.Particle(m, "rb")
d=IMP.core.XYZR.setup_particle(p)
d.set_radius(10)
d.set_coordinates_are_optimized(True)
rb= IMP.core.RigidBody.setup_particle(p, IMP.algebra.ReferenceFrame3D())
for i in range(3):
pc= IMP.Particle(m, str(i))
d=IMP.core.XYZR.setup_particle(pc)
d.set_radius(2)
v= IMP.algebra.Vector3D(0,0,0)
v[i]=5
d.set_coordinates(v)
rb.add_member(pc)
# to make sure coordinates get updated
cr= IMP._ConstRestraint(0, rb.get_rigid_members())
sf = IMP.core.RestraintsScoringFunction([cr])
dd= IMP.atom.RigidBodyDiffusion.setup_particle(p)
nD=10.0*dd.get_rotational_diffusion_coefficient()
dd.set_rotational_diffusion_coefficient(nD)
dt=10000
bd= IMP.atom.BrownianDynamics(m)
bd.set_scoring_function(sf)
bd.set_maximum_time_step(dt)
os= IMP.npctransport.ChainStatisticsOptimizerState(rb.get_rigid_members())
os.set_period(10)
bd.add_optimizer_state(os)
os2= IMP.npctransport.BodyStatisticsOptimizerState(p)
os2.set_period(10)
bd.add_optimizer_state(os2)
IMP.set_log_level(IMP.SILENT)
bd.set_log_level(IMP.SILENT)
bd.optimize(5000)
Dout= os.get_correlation_time()
Dout2= os2.get_correlation_time()
Din= dd.get_rotational_diffusion_coefficient()
v=1.0/(2.0*Dout)
print("Corr1, Corr2, rot_dif_coeff, v", Dout, Dout2, Din, v)
self.assertAlmostEqual(Dout, Dout2, delta=.1*Dout)
dfs= os.get_local_diffusion_coefficients()
print(dfs)
for d in dfs:
self.assertAlmostEqual(0, d, delta=.1)
def test_global_min3(self):
"""Test caching sampling with edge scores"""
m = IMP.Model()
m.set_log_level(IMP.SILENT)
ps = []
ds = []
for i in range(0, 3):
p = IMP.Particle(m)
d = IMP.core.XYZ.setup_particle(p)
print(d)
ds.append(d)
ps.append(p)
pts = [IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(1, 0, 0),
IMP.algebra.Vector3D(2, 0, 0),
IMP.algebra.Vector3D(3, 0, 0)]
particle_state = IMP.domino.XYZStates(pts)
pst = IMP.domino.ParticleStatesTable()
r = IMP.RestraintSet(m)
for p in ps:
pst.set_particle_states(p, particle_state)
r.add_restraint(IMP._ConstRestraint(1, [p]))
sst = IMP.domino.BranchAndBoundAssignmentsTable(pst, [])
r.add_restraint(IMP.core.DistanceRestraint(m,
IMP.core.Harmonic(1, 1), ps[0], ps[1]))
r.add_restraint(IMP.core.DistanceRestraint(m,
IMP.core.Harmonic(1, 1), ps[1], ps[2]))
#sevt= IMP.domino.ModelSubsetEvaluatorTable(m, pst)
sampler = IMP.domino.DominoSampler(m, pst)
sampler.set_restraints(r)
# sampler.set_subset_evaluator_table(sevt);
sampler.set_log_level(IMP.VERBOSE)
# sampler.set_assignments_table(sst)
r.set_maximum_score(3.1)
print("getting sample")
cs = sampler.create_sample()
print("done")
self.assertGreater(cs.get_number_of_configurations(), 0)
for i in range(0, cs.get_number_of_configurations()):
print("loading ", i)
cs.load_configuration(i)
print("testing")
dist = IMP.core.get_distance(ds[0], ds[1])
print(dist)
self.assertLess((dist - 1) ** 2, .1)
self.assertLess((IMP.core.get_distance(ds[1], ds[2]) - 1) ** 2, .1)
def test_simple_rest(self):
"""Check reference counting of restraints"""
refcnt = IMP.test.RefCountChecker(self)
m= IMP.Model("ref counted restraints")
r= IMP._ConstRestraint(1)
s= IMP.RestraintSet()
m.add_restraint(s)
m.add_restraint(r)
s.add_restraint(r)
m.evaluate(False)
refcnt.assert_number(3)
# Model should hold a ref to restraints, so nothing should be freed
# until it is
del r
refcnt.assert_number(3)
del s
refcnt.assert_number(3)
del m
refcnt.assert_number(0)
def test_delete_model_iterator(self):
"""Python Restraints from iterators should survive model deletion"""
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("python restraint survival")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
del r
# Now create new Python Restraint r from C++ iterator
# This calls swig::from() internally, which is modified by template
# specialization in our SWIG interface.
r = rs.get_restraints()[0]
# Python reference r plus C++ reference from m
self.assertEqual(r.get_ref_count(), 2)
del m, rs
# Now only the Python reference r should survive
self.assertEqual(r.get_ref_count(), 1)
refcnt.assert_number(1)
del r
refcnt.assert_number(0)
def test_delete_model_accessor_2(self):
"Python Restraints from vector accessors should survive model deletion"
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("restraint survival")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
del r
# Now create new Python Restraint r from a C++ vector accessor
# These accessors call specific methods in the SWIG wrapper which
# are modified by typemaps in our interface.
r = rs.get_restraints()[0]
# Python reference r plus C++ reference from m
self.assertEqual(r.get_ref_count(), 2)
del m, rs
# Now only the Python reference r should survive
self.assertEqual(r.get_ref_count(), 1)
refcnt.assert_number(1)
del r
refcnt.assert_number(0)
def test_delete_model_iterator(self):
"""Python Restraints from iterators should survive model deletion"""
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("python restraint survival")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
del r
# Now create new Python Restraint r from C++ iterator
# This calls swig::from() internally, which is modified by template
# specialization in our SWIG interface.
r = rs.get_restraints()[0]
# Python reference r plus C++ reference from m
self.assertEqual(r.get_ref_count(), 2)
del m, rs
# Now only the Python reference r should survive
self.assertEqual(r.get_ref_count(), 1)
refcnt.assert_number(1)
del r
refcnt.assert_number(0)
def test_delete_model_accessor_2(self):
"Python Restraints from vector accessors should survive model deletion"
refcnt = IMP.test.RefCountChecker(self)
m = IMP.Model("restraint survival")
rs = IMP.RestraintSet(m)
r = IMP._ConstRestraint(m, [], 1)
rs.add_restraint(r)
del r
# Now create new Python Restraint r from a C++ vector accessor
# These accessors call specific methods in the SWIG wrapper which
# are modified by typemaps in our interface.
r = rs.get_restraints()[0]
# Python reference r plus C++ reference from m
self.assertEqual(r.get_ref_count(), 2)
del m, rs
# Now only the Python reference r should survive
self.assertEqual(r.get_ref_count(), 1)
refcnt.assert_number(1)
del r
refcnt.assert_number(0)
def test_decomposition_5(self):
"""Test cache with simple restraint"""
(m, ps, r, pst, ik, cache) = self._create_stuff()
rs = IMP.RestraintSet(m, 1.0, "outer")
r = IMP._ConstRestraint(1, [ps[0]])
r.set_name("const 2")
rs.add_restraint(r)
r.set_maximum_score(.5)
cache.add_restraints([rs])
print("info:")
cache.show_restraint_information()
subset = IMP.domino.Subset([ps[0]])
rsb = cache.get_restraints(subset, [])
self.assertEqual(len(rsb), 1)
slc = cache.get_slice(rsb[0], subset)
self.assertEqual(len(slc), 1)
aslc = slc.get_sliced(IMP.domino.Assignment(range(len(ps))))
self.assertEqual(len(aslc), 1)
score = cache.get_score(rsb[0], aslc)
print(score)
self.assert_(score > 1000)
def test_decomposition_5(self):
"""Test cache with simple restraint"""
(m, ps, r, pst, ik, cache) = self._create_stuff()
rs = IMP.RestraintSet(m, 1.0, "outer")
r = IMP._ConstRestraint(1, [ps[0]])
r.set_name("const 2")
rs.add_restraint(r)
r.set_maximum_score(.5)
cache.add_restraints([rs])
print("info:")
cache.show_restraint_information()
subset = IMP.domino.Subset([ps[0]])
rsb = cache.get_restraints(subset, [])
self.assertEqual(len(rsb), 1)
slc = cache.get_slice(rsb[0], subset)
self.assertEqual(len(slc), 1)
aslc = slc.get_sliced(IMP.domino.Assignment(range(len(ps))))
self.assertEqual(len(aslc), 1)
score = cache.get_score(rsb[0], aslc)
print(score)
self.assert_(score > 1000)
def test_global_min3(self):
"""Test sampling with edge scores"""
m = IMP.Model()
m.set_log_level(IMP.SILENT)
ps = []
for i in range(0, 3):
p = IMP.Particle(m)
d = IMP.core.XYZ.setup_particle(p)
ps.append(p)
pts = [
IMP.algebra.Vector3D(0, 0, 0),
IMP.algebra.Vector3D(1, 0, 0),
IMP.algebra.Vector3D(2, 0, 0),
IMP.algebra.Vector3D(3, 0, 0)
]
particle_state = IMP.domino.XYZStates(pts)
pst = IMP.domino.ParticleStatesTable()
r = IMP.RestraintSet(m)
for p in ps:
pst.set_particle_states(p, particle_state)
r.add_restraint(IMP._ConstRestraint(1, [p]))
r.add_restraint(
IMP.core.DistanceRestraint(m, IMP.core.Harmonic(1, 1), ps[0],
ps[1]))
r.add_restraint(
IMP.core.DistanceRestraint(m, IMP.core.Harmonic(1, 1), ps[1],
ps[2]))
r.set_maximum_score(3.1)
sampler = IMP.domino.DominoSampler(m, pst)
sampler.set_restraints([r])
sampler.set_log_level(IMP.VERBOSE)
cs = sampler.create_sample()
self.assertGreater(cs.get_number_of_configurations(), 0)
for i in range(0, cs.get_number_of_configurations()):
cs.load_configuration(i)
self.assertLess((IMP.core.get_distance(IMP.core.XYZ(
ps[0]), IMP.core.XYZ(ps[1])) - 1)**2, .1)
self.assertLess((IMP.core.get_distance(IMP.core.XYZ(
ps[1]), IMP.core.XYZ(ps[2])) - 1)**2, .1)
def test_simple_rest(self):
"""Check reference counting of restraints"""
refcnt = IMP.test.RefCountChecker(self)
IMP.set_log_level(IMP.MEMORY)
m = IMP.Model("M")
r = IMP._ConstRestraint(m, [], 1)
r.set_name("R")
s = IMP.RestraintSet(m, 1.0, "S")
s.add_restraint(r)
"""m.evaluate(False)
refcnt.assert_number(3)
# Model should hold a ref to restraints, so nothing should be freed
# until it is
"""
print(r.get_ref_count(), s.get_ref_count(), m.get_ref_count())
del r
refcnt.assert_number(4)
print(s.get_ref_count(), m.get_ref_count())
del s
refcnt.assert_number(2)
print(m.get_ref_count())
del m
print("check")
refcnt.assert_number(0)
def test_simple_rest(self):
"""Check reference counting of restraints"""
refcnt = IMP.test.RefCountChecker(self)
IMP.set_log_level(IMP.MEMORY)
m = IMP.Model("M")
r = IMP._ConstRestraint(m, [], 1)
r.set_name("R")
s = IMP.RestraintSet(m, 1.0, "S")
s.add_restraint(r)
"""m.evaluate(False)
refcnt.assert_number(3)
# Model should hold a ref to restraints, so nothing should be freed
# until it is
"""
print(r.get_ref_count(), s.get_ref_count(), m.get_ref_count())
del r
refcnt.assert_number(3)
print(s.get_ref_count(), m.get_ref_count())
del s
refcnt.assert_number(1)
print(m.get_ref_count())
del m
print("check")
refcnt.assert_number(0)
"""An optimizer state which prints out the last scores of some restraints"""
def __init__(self, rs):
IMP.OptimizerState.__init__(self, rs[0].get_model(),
"MyOptimizerState%1%")
self.rs = rs
def update(self):
for r in self.rs:
print(r.get_name(), r.get_last_score())
# some code to create and evaluate it
k = IMP.FloatKey("a key")
m = IMP.Model()
# we don't have any real restraints in the kernel
r0 = IMP._ConstRestraint(m, [], 1)
r0.set_name("restraint 0")
r1 = IMP._ConstRestraint(m, [], 2)
r1.set_name("restraint 1")
rs = IMP.RestraintSet([r0, r1], 1.0)
sf = rs.create_scoring_function()
os = MyOptimizerState([r0, r1])
os.set_name("python optimizer state")
# we don't have any optimizers either
co = IMP._ConstOptimizer(m)
co.set_scoring_function(sf)
co.add_optimizer_state(os)
print(co.optimize(100))
class MyOptimizerState(IMP.OptimizerState):
def __init__(self, rs):
IMP.OptimizerState.__init__(self, rs[0].get_model(),
"MyOptimizerState%1%")
self.rs = rs
def update(self):
for r in self.rs:
print(r.get_name(), r.get_last_score())
# some code to create and evaluate it
k = IMP.FloatKey("a key")
m = IMP.Model()
# we don't have any real restraints in the kernel
r0 = IMP._ConstRestraint(m, [], 1)
r0.set_name("restraint 0")
r1 = IMP._ConstRestraint(m, [], 2)
r1.set_name("restraint 1")
rs = IMP.RestraintSet([r0, r1], 1.0)
sf = rs.create_scoring_function()
os = MyOptimizerState([r0, r1])
os.set_name("python optimizer state")
# we don't have any optimizers either
co = IMP._ConstOptimizer(m)
co.set_scoring_function(sf)
co.add_optimizer_state(os)
print(co.optimize(100))
import IMP
# an optimizer state which prints out model statistics.
class MyOptimizerState(IMP.OptimizerState):
def __init__(self):
IMP.OptimizerState.__init__(self)
def update(self):
self.get_optimizer().get_model().show_restraint_score_statistics()
# some code to create and evaluate it
k= IMP.FloatKey("a key")
m= IMP.Model()
# we don't have any real restraints in the kernel
r0=IMP._ConstRestraint(1)
r0.set_name("restraint 0")
m.add_restraint(r0)
r1=IMP._ConstRestraint(2)
r1.set_name("restraint 1")
m.add_restraint(r1)
os= MyOptimizerState()
os.set_name("python optimizer state")
# we don't have any optimizers either
co= IMP._ConstOptimizer(m)
co.add_optimizer_state(os)
m.set_gather_statistics(True)
# so we only see the statistics
IMP.set_log_level(IMP.SILENT)
print co.optimize(100)
# this is needed to clean up memory properly for some reason
