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)