def test_derivatives(self):
"""Test get/set of derivatives"""
(model, particles) = self.setup()
p = particles[0]
self.assertEqual(p.get_derivative(xkey), 0.0)
da = IMP.DerivativeAccumulator()
p.add_to_derivative(xkey, 10.0, da)
self.assertEqual(p.get_derivative(xkey), 10.0)
da = IMP.DerivativeAccumulator(2.0)
p.add_to_derivative(xkey, 10.0, da)
self.assertEqual(p.get_derivative(xkey), 30.0)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.kappa = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.DA = IMP.DerivativeAccumulator()
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.set_log_level(IMP.MEMORY)
IMP.set_log_level(0)
self.m = IMP.Model()
self.sigma = Scale.setup_particle(IMP.Particle(self.m), 1.0)
self.DA = IMP.DerivativeAccumulator()
self.J = IMP.isd.JeffreysRestraint(self.m, self.sigma)
def test_invalid_type(self):
"""Check TypedPairScore behavior with invalid particle types"""
m = IMP.kernel.Model()
pa, pb = self._make_particles(m, (0, 1))
da = IMP.DerivativeAccumulator()
ps1 = IMP.core.TypedPairScore(typekey, True)
self.assertEqual(ps1.evaluate((pa, pb), da), 0.0)
ps2 = IMP.core.TypedPairScore(typekey, False)
self.assertRaises(ValueError, ps2.evaluate, (pa, pb), da)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.set_log_level(IMP.MEMORY)
IMP.set_log_level(0)
self.m = IMP.Model()
self.alpha = Nuisance.setup_particle(IMP.Particle(self.m), 1.0)
self.beta = Nuisance.setup_particle(IMP.Particle(self.m), 1.0)
self.mean = Linear1DFunction(self.alpha, self.beta)
self.DA = IMP.DerivativeAccumulator()
def setUp(self):
IMP.test.TestCase.setUp(self)
self.m = IMP.kernel.Model()
IMP.base.set_log_level(0)
self.tau = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.lam = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.particles = [self.tau, self.lam]
self.cov = Covariance1DFunction(*self.particles)
self.DA = IMP.DerivativeAccumulator()
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.kappa = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.DA = IMP.DerivativeAccumulator()
self.J = IMP.isd.vonMisesKappaJeffreysRestraint(self.m, self.kappa)
self.m.add_restraint(self.J)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.sigma = 2.0
self.mu = 1.0
self.x = Nuisance.setup_particle(IMP.kernel.Particle(self.m), 2.0)
self.locations = [self.x, self.mu]
self.all = self.locations + [self.sigma]
self.DA = IMP.DerivativeAccumulator()
def test_add_derivatives(self):
"""Test normal derivatives are added correctly."""
m = IMP.Model()
for i in range(10):
s = IMP.core.Surface.setup_particle(IMP.Particle(m))
v = IMP.algebra.get_random_vector_on_unit_sphere()
s.add_to_normal_derivatives(v, IMP.DerivativeAccumulator())
self.assertAlmostEqual(
(s.get_normal_derivatives() - v).get_magnitude(), 0.)
for i in range(3):
self.assertAlmostEqual(s.get_normal_derivative(i), v[i])
def test_add_to_weights_derivatives(self):
for n in range(1, 20):
w = Weight.setup_particle(IMP.Particle(self.m), n)
ws = np.random.uniform(size=n)
ws /= np.sum(ws)
w.set_weights(ws)
dw = np.random.normal(size=n)
w.add_to_weights_derivatives(dw, IMP.DerivativeAccumulator())
dw2 = w.get_weights_derivatives()
dw2 = [dw2[i] for i in range(n)]
self.assertSequenceAlmostEqual(list(dw), dw2, delta=1e-6)
def test_symmetry(self):
"""Test the transform pair score basics"""
IMP.base.set_log_level(IMP.base.VERBOSE)
m = IMP.kernel.Model()
p0 = IMP.kernel.Particle(m)
d0 = IMP.core.XYZ.setup_particle(p0)
p1 = IMP.kernel.Particle(m)
d1 = IMP.core.XYZ.setup_particle(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((p0, p1), None), 0)
self.assertNotEqual(tps.evaluate((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((p0, p1), None), 0, delta=.01)
self.assertNotEqual(tps.evaluate((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"
m.evaluate(True)
tps.evaluate((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_add_to_weight_derivative(self):
for n in range(1, 20):
w = Weight.setup_particle(IMP.Particle(self.m), n)
ws = np.random.uniform(size=n)
ws /= np.sum(ws)
w.set_weights(ws)
for k in range(0, n):
dwk = np.random.normal()
w.add_to_weight_derivative(k, dwk, IMP.DerivativeAccumulator())
self.assertAlmostEqual(
w.get_weight_derivative(k), dwk, delta=1e-6
)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.G = Scale.setup_particle(IMP.kernel.Particle(self.m), 10.0)
self.Rg = Scale.setup_particle(IMP.kernel.Particle(self.m), 10.0)
self.d = Scale.setup_particle(IMP.kernel.Particle(self.m), 4.0)
self.s = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.A = Scale.setup_particle(IMP.kernel.Particle(self.m), 2.0)
self.particles = [self.G, self.Rg, self.d, self.s, self.A]
self.mean = GeneralizedGuinierPorodFunction(*self.particles)
self.DA = IMP.DerivativeAccumulator()
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.p0 = IMP.core.XYZR.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Sphere3D(IMP.algebra.Vector3D(0, 0, 0), 1))
self.p1 = IMP.core.XYZR.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Sphere3D(IMP.algebra.Vector3D(5, 1, 1), 2))
self.DA = IMP.DerivativeAccumulator()
self.ps = RepulsiveDistancePairScore(0.0, 1.0)
self.pc = IMP.container.ListPairContainer(self.m)
self.pc.add_particle_pair((self.p0, self.p1))
self.m.add_restraint(IMP.container.PairsRestraint(self.ps, self.pc))
def test_combine(self):
"""Test combining example UnaryFunction with a PairScore"""
m = IMP.Model()
p1 = m.add_particle("p1")
p2 = m.add_particle("p2")
d1 = IMP.core.XYZ.setup_particle(m, p1, IMP.algebra.Vector3D(1, 2, 3))
d2 = IMP.core.XYZ.setup_particle(m, p2, IMP.algebra.Vector3D(4, 5, 6))
for typ in (IMP.example.ExampleUnaryFunction,
IMP.example.PythonExampleUnaryFunction):
u = typ(2.0, 10.0)
ps = IMP.core.DistancePairScore(u)
da = IMP.DerivativeAccumulator()
self.assertAlmostEqual(ps.evaluate_index(m, [p1, p2], da),
51.08,
delta=0.01)
def test_evaluate(self):
"""Check TypedPairScore::evaluate()"""
ps = IMP.core.TypedPairScore(typekey)
cps = IMP.kernel._ConstPairScore(5)
ps.set_pair_score(cps, 0, 1)
# Keep Python reference to the model so that the particles
# aren't destroyed
m = IMP.kernel.Model()
pa, pb = self._make_particles(m, (0, 1))
da = IMP.DerivativeAccumulator()
# The ordering of the particles should not matter:
pab = (pa, pb)
pba = (pb, pa)
self.assertEqual(ps.evaluate(pab, da), 5.0)
self.assertEqual(ps.evaluate(pba, da), 5.0)
def test_distance(self):
"""Test that distance restraints are reasonable"""
self._make_restraints()
# score should not change with deriv calcs
accum = IMP.DerivativeAccumulator()
# score should be equivalent if attribute is used or equivalent
# hard-coded distance is used
for i in range(9):
self.assertEqual(self.rsrs[i].evaluate(False),
self.rsrs[i + 9].evaluate(False),
"should get same distance whether explicit "
"or through radii")
# exact match
self.assertEqual(
self.rsrs[0].evaluate(False),
0.0,
"unexpected distance score")
self.assertEqual(
self.rsrs[1].evaluate(False),
0.0,
"unexpected distance score")
self.assertEqual(
self.rsrs[2].evaluate(False),
0.0,
"unexpected distance score")
# too close
self.assertEqual(
self.rsrs[0].evaluate(False),
0.0,
"unexpected distance score")
self.assertTrue(
self.rsrs[1].evaluate(False) == self.rsrs[
2].evaluate(False) == 0.0,
"unexpected distance score")
# too far
self.assertEqual(
self.rsrs[1].evaluate(False),
0.0,
"unexpected distance score")
self.assertTrue(
self.rsrs[0].evaluate(False) == self.rsrs[
2].evaluate(False) == 0.0,
"unexpected distance score")
def test_evaluate_derivative_wrt_sigma(self):
"""Test NormalSigmaPCRestraint.evaluate_derivative_Dxi"""
m = IMP.Model()
n = 10
for i in range(n):
su = random.uniform(5, 20)
s = create_scale(m)
a = random.uniform(0, .5)
r = NormalSigmaPCRestraint(s, su, a)
exp_deriv = -math.log(a) / su
da = IMP.DerivativeAccumulator()
r.unprotected_evaluate(da)
self.assertAlmostEqual(s.get_scale_derivative(), exp_deriv,
delta=1e-6)
r.set_was_used(True)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.sigma = Scale.setup_particle(IMP.kernel.Particle(self.m), 2.0)
self.gamma = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.p0 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(0, 0, 0))
self.p1 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(1, 1, 1))
self.DA = IMP.DerivativeAccumulator()
self.Jsi = IMP.isd.JeffreysRestraint(self.m, self.sigma)
self.Jga = IMP.isd.JeffreysRestraint(self.m, self.gamma)
self.V_obs = 3.0
self.noe = IMP.isd.NOERestraint(self.m, self.p0, self.p1, self.sigma,
self.gamma, self.V_obs)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.set_log_level(IMP.MEMORY)
IMP.set_log_level(0)
self.m = IMP.Model()
self.p0 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m),
IMP.algebra.Vector3D(0, 0, 0))
self.p1 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m),
IMP.algebra.Vector3D(1, 1, 1))
self.p2 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m),
IMP.algebra.Vector3D(1, 0, 0))
self.DA = IMP.DerivativeAccumulator()
self.V_obs = 3.0
self.ls = \
IMP.container.ListPairContainer(self.m,
[(self.p0, self.p1), (self.p0, self.p2)])
self.noe = IMP.isd.MarginalHBondRestraint(self.m)
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
# setup dihedral angle of pi/2
self.p0 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(1, 0, 0))
self.p1 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(0, 0, 0))
self.p2 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(0, 1, 0))
self.p3 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(0, 1, 1))
# scale particle
self.kappa = Scale.setup_particle(IMP.kernel.Particle(self.m), 2.0)
self.DA = IMP.DerivativeAccumulator()
def setUp(self):
IMP.test.TestCase.setUp(self)
# IMP.base.set_log_level(IMP.MEMORY)
IMP.base.set_log_level(0)
self.m = IMP.kernel.Model()
self.sigma = Scale.setup_particle(IMP.kernel.Particle(self.m), 2.0)
self.gamma = Scale.setup_particle(IMP.kernel.Particle(self.m), 1.0)
self.p0 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(0, 0, 0))
self.p1 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(1, 1, 1))
self.p2 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m),
IMP.algebra.Vector3D(1, 0, 0))
self.DA = IMP.DerivativeAccumulator()
self.V_obs = 3.0
self.ls = \
IMP.container.ListPairContainer(
[(self.p0, self.p1), (self.p0, self.p2)])
self.noe = IMP.isd.AmbiguousNOERestraint(self.m, self.ls, self.sigma,
self.gamma, self.V_obs)
def test_unprotected_evaluate(self):
try:
from scipy.stats import gamma
except ImportError:
self.skipTest("this test requires the scipy Python module")
theta = 2.0
kappa = 1.6
sigma_value = 15.0
m, p = self.initialize()
sigma = Scale.setup_particle(p, sigma_value)
DA = IMP.DerivativeAccumulator()
gp = GammaPrior(m, p, kappa, theta)
self.assertAlmostEqual(
gp.unprotected_evaluate(DA),
-1 * numpy.log(gamma.pdf(sigma_value / 10, kappa, 0.0, theta)))
def test_soft_restraint_values(self):
"""Test soft sub- and super-surface restraints."""
m = IMP.Model()
s = IMP.core.Surface.setup_particle(IMP.Particle(m))
d = IMP.core.XYZR.setup_particle(IMP.Particle(m),
IMP.algebra.Sphere3D((0, 0, 0), 1.0))
pip = (s.get_particle_index(), d.get_particle_index())
da = IMP.DerivativeAccumulator()
ps_sup = IMP.core.SoftSuperSurfacePairScore(1.)
ps_sub = IMP.core.SoftSubSurfacePairScore(1.)
for i in range(100):
d.set_coordinates(
30 * IMP.algebra.get_random_vector_on_unit_sphere())
height = IMP.core.get_height(s, d)
depth = IMP.core.get_depth(s, d)
exp_super_score = _harmonic_lb(height, 0., 1.)
exp_sub_score = _harmonic_lb(depth, 0., 1.)
self.assertAlmostEqual(ps_sup.evaluate_index(m, pip, da),
exp_super_score)
self.assertAlmostEqual(ps_sub.evaluate_index(m, pip, da),
exp_sub_score)
def test_pair_score(self):
"""Test example PairScore"""
m = IMP.Model()
p1 = m.add_particle("p1")
p2 = m.add_particle("p2")
d1 = IMP.core.XYZ.setup_particle(m, p1, IMP.algebra.Vector3D(1, 2, 3))
d2 = IMP.core.XYZ.setup_particle(m, p2, IMP.algebra.Vector3D(4, 5, 6))
# Test both implementations: C++ and Python
for typ in (IMP.example.ExamplePairScore,
IMP.example.PythonExamplePairScore):
p = typ(2.0, 10.0)
da = IMP.DerivativeAccumulator()
self.assertAlmostEqual(p.evaluate_index(m, [p1, p2], da),
51.08,
delta=0.01)
# Note that we can't test derivatives because they haven't been
# initialized
self.assertIn("PairScore", str(p))
self.assertIn("PairScore", repr(p))
self.assertIn("example", p.get_version_info().get_module())
self.assertEqual(len(p.get_inputs(m, [p1, p2])), 2)
def test_rops(self):
"""Checking refine pairs pair score"""
IMP.set_log_level(IMP.VERBOSE)
m = IMP.Model()
pp = m.add_particle("p")
hpp = IMP.core.Hierarchy.setup_particle(m, pp)
c = []
for i in range(0, 10):
p = IMP.Particle(m)
hp = IMP.core.Hierarchy.setup_particle(p)
hpp.add_child(hp)
c.append(p)
pr = IMP.core.ChildrenRefiner(IMP.core.Hierarchy.get_default_traits())
cps = IMP._ConstPairScore(1)
rps = IMP.core.RefinedPairsPairScore(pr, cps)
ppp = (pp, pp)
print(type(rps))
print(type(rps.evaluate_index))
da = IMP.DerivativeAccumulator()
print(type(pp))
print(type(ppp))
self.assertEqual(rps.evaluate_index(m, ppp, da), 100)
def _initialize_model(self):
print("radius", radius, "slab radius", slab_pore_radius, "slab_height",
slab_height)
m = IMP.Model()
self.m = m
p = IMP.Particle(m, "diffuser")
d = IMP.core.XYZR.setup_particle(p)
self.d = d
d.set_coordinates_are_optimized(True)
d.set_radius(radius)
bb = IMP.algebra.BoundingBox3D(
0.5 * IMP.algebra.Vector3D(-boxw, -boxw, -boxw),
0.5 * IMP.algebra.Vector3D(boxw, boxw, boxw))
p_slab = IMP.Particle(m, "slab")
IMP.npctransport.SlabWithCylindricalPore.setup_particle \
(p_slab, slab_height, slab_pore_radius)
self.assertTrue(
IMP.npctransport.SlabWithCylindricalPore.get_is_setup(p_slab))
# test cast to slab
slab = IMP.npctransport.SlabWithPore(p_slab)
self.slab = slab
self.assertEqual(slab.get_pore_radius(), slab_pore_radius)
self.assertEqual(slab.get_thickness(), slab_height)
slabps = IMP.npctransport.SlabWithCylindricalPorePairScore(1.0)
self.assertFalse(slab.get_pore_radius_is_optimized()
) # verify correct default value
r = IMP.core.PairRestraint(
m, slabps, [p_slab.get_index(), p.get_index()], "slab")
self.r = r
score_init = slabps.evaluate_index(
m, [p_slab.get_index(), p.get_index()],
IMP.DerivativeAccumulator(1.0))
self.assertEqual(score_init, 0.0)
# Create optimizer:
cg = IMP.core.SteepestDescent(m)
cg.set_scoring_function(r)
cg.set_step_size(0.01)
self.opt = cg
def test_depth_values(self):
"""Test harmonic and generic distance scores."""
m = IMP.Model()
s = IMP.core.Surface.setup_particle(IMP.Particle(m))
d = IMP.core.XYZR.setup_particle(IMP.Particle(m),
IMP.algebra.Sphere3D((0, 0, 0), 1.0))
pip = (s.get_particle_index(), d.get_particle_index())
da = IMP.DerivativeAccumulator()
h = IMP.core.Harmonic(0, 1)
ps1 = IMP.core.SurfaceDepthPairScore(h)
for i in range(100):
k = random.uniform(0, 10)
mean = random.uniform(-5, 5)
h.set_k(k)
h.set_mean(mean)
d.set_coordinates(
30 * IMP.algebra.get_random_vector_on_unit_sphere())
dist = IMP.core.get_depth(s, d)
exp_score = _harmonic(dist, mean, k)
self.assertAlmostEqual(ps1.evaluate_index(m, pip, da), exp_score)
ps2 = IMP.core.HarmonicSurfaceDepthPairScore(mean, k)
self.assertAlmostEqual(ps2.evaluate_index(m, pip, da), exp_score)
ps2.set_was_used(True)
def test_deriv(self):
"Test setting/getting Scale derivative"
self.sigma.add_to_scale_derivative(123, IMP.DerivativeAccumulator())
self.assertAlmostEqual(self.sigma.get_scale_derivative(),
123.0,
delta=0.01)
