def create_particles(self): x = Nuisance.setup_particle(IMP.Particle(self.m), 2.0) mu = Nuisance.setup_particle(IMP.Particle(self.m), 1.0) sigma = Scale.setup_particle(IMP.Particle(self.m), 2.0) nu = Scale.setup_particle(IMP.Particle(self.m), 3.0) all_nuis = [x, mu, sigma, nu] return all_nuis
def test_scale_down(self): n = IMP.Particle(self.m) Scale.setup_particle(n, 1.0) n.set_value(Scale.get_scale_key(), -0.1) self.rs.evaluate(False) self.assertAlmostEqual(n.get_value(Scale.get_scale_key()), 0.0, delta=1e-7) self.assertAlmostEqual(self.rs.values[0], 0.0)
def test_scale_down(self): n=IMP.kernel.Particle(self.m) Scale.setup_particle(n,1.0) n.set_value(Scale.get_scale_key(), -0.1) self.m.evaluate(False) self.assertAlmostEqual(n.get_value(Scale.get_scale_key()), 0.0, delta=1e-7) self.assertAlmostEqual(self.rs.values[0],0.0)
def test_scale_up(self): n=IMP.kernel.Particle(self.m) Scale.setup_particle(n,1.0) Scale(n).set_upper(1.5) n.set_value(Scale.get_scale_key(), 10.0) self.m.evaluate(False) self.assertAlmostEqual(n.get_value(Scale.get_scale_key()), 1.5, delta=1e-7) self.assertAlmostEqual(self.rs.values[0],1.5)
def test_scale_up(self): n = IMP.Particle(self.m) Scale.setup_particle(n, 1.0) Scale(n).set_upper(1.5) n.set_value(Scale.get_scale_key(), 10.0) self.rs.evaluate(False) self.assertAlmostEqual(n.get_value(Scale.get_scale_key()), 1.5, delta=1e-7) self.assertAlmostEqual(self.rs.values[0], 1.5)
def test_scale_down(self): n=IMP.Particle(self.m) Scale.setup_particle(n,1.0) self.m.add_score_state(IMP.core.SingletonConstraint( IMP.isd.NuisanceRangeModifier(), None, n)) n.set_value(Scale.get_scale_key(), -0.1) self.m.evaluate(False) self.assertAlmostEqual(n.get_value(Scale.get_scale_key()), 0.0, delta=1e-7) self.assertAlmostEqual(self.rs.values[0],0.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 test_Setup2(self): si = Scale.setup_particle(IMP.Particle(self.m), 2.0) si.set_lower(0.1) si.set_upper(10) self.assertAlmostEqual(float(si.get_scale()),2.0, delta=1e-6) self.assertAlmostEqual(float(si.get_lower()),0.1, delta=1e-6) self.assertAlmostEqual(float(si.get_upper()),10.0, delta=1e-6)
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_Setup1(self): "Test scale setup without lower/upper" si = Scale.setup_particle(IMP.Particle(self.m)) self.assertAlmostEqual(float(si.get_scale()),1.0, delta=1e-6) self.assertAlmostEqual(float(si.get_lower()),0.0, delta=1e-6) self.assertFalse(si.has_upper()) self.assertEqual(si.get_upper(), 1e3000) # 1e3000 ~= inf
def test_Setup1(self): "Test scale setup without lower/upper" si = Scale.setup_particle(IMP.kernel.Particle(self.m)) self.assertAlmostEqual(float(si.get_scale()), 1.0, delta=1e-6) self.assertAlmostEqual(float(si.get_lower()), 0.0, delta=1e-6) self.assertFalse(si.get_has_upper()) self.assertEqual(si.get_upper(), 1e3000) # 1e3000 ~= inf
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 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 test_Setup2(self): "Test scale setup with lower/upper" si = Scale.setup_particle(IMP.kernel.Particle(self.m), 2.0) si.set_lower(0.1) si.set_upper(10) self.assertAlmostEqual(float(si.get_scale()), 2.0, delta=1e-6) self.assertAlmostEqual(float(si.get_lower()), 0.1, delta=1e-6) self.assertAlmostEqual(float(si.get_upper()), 10.0, 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.Model() self.sigma = Scale.setup_particle(IMP.Particle(self.m), 1.0) self.DA = IMP.DerivativeAccumulator() self.J = IMP.isd.JeffreysRestraint(self.sigma)
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() self.J = IMP.isd.vonMisesKappaJeffreysRestraint(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.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.Model() self.sigma = Scale.setup_particle(IMP.Particle(self.m), 2.0) self.gamma = Scale.setup_particle(IMP.Particle(self.m), 1.0) 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.p0,self.p1),(self.p0,self.p2)]) self.noe = IMP.isd.AmbiguousNOERestraint(self.ls, self.sigma, self.gamma, self.V_obs)
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_simple(self): """Simple test of LognormalAmbiguousRestraint""" m = IMP.Model() p1 = IMP.core.XYZ.setup_particle(IMP.Particle(m), IMP.algebra.Vector3D(0,0,0)) p2 = IMP.core.XYZ.setup_particle(IMP.Particle(m), IMP.algebra.Vector3D(3,3,3)) ki = Scale.setup_particle(IMP.Particle(m), 0.0) ki.set_lower(0.) ki.set_upper(0.) sigma = Scale.setup_particle(IMP.Particle(m), 2.0) omega = Scale.setup_particle(IMP.Particle(m), 1.0) omega.set_lower(1.) omega.set_upper(10000.) lnar = IMP.isd.LognormalAmbiguousRestraint(p1, p2, ki, sigma) lnar.add_contribution(50., omega) self.assertAlmostEqual(lnar.evaluate(True), 6.165, delta=0.001) self.assertAlmostEqual(-math.log(lnar.get_probability()), lnar.evaluate(False), delta=1e-4) self.assertEqual(lnar.get_number_of_contributions(), 1)
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.mu = 1.0 self.x = 2.0 self.locations = [self.x, self.mu] self.all = self.locations + [self.sigma] 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.Model() self.sigma = Scale.setup_particle(IMP.Particle(self.m), 2.0) self.mu = 1.0 self.x = 2.0 self.locations=[self.x, self.mu] self.all = self.locations+[self.sigma] 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.kda = Scale.setup_particle(IMP.kernel.Particle(self.m), 4.0) self.Ida = Scale.setup_particle(IMP.kernel.Particle(self.m), 3.0) self.R0 = Scale.setup_particle(IMP.kernel.Particle(self.m), 50.0) self.sigma = Scale.setup_particle(IMP.kernel.Particle(self.m), 0.005) self.Pbl = Scale.setup_particle(IMP.kernel.Particle(self.m), 0.7) self.p0 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m), IMP.algebra.Vector3D(50, 0, 0)) self.p1 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m), IMP.algebra.Vector3D(0, 50, 0)) self.p2 = IMP.core.XYZ.setup_particle(IMP.kernel.Particle(self.m), IMP.algebra.Vector3D(0, 0, 0)) self.fexp = 1.5 self.fret0 = IMP.isd.FretRestraint([self.p0], [self.p1, self.p2], self.kda, self.Ida, self.R0, self.sigma, self.Pbl, self.fexp) self.fret1 = IMP.isd.FretRestraint([self.p0, self.p1], [self.p2], self.kda, self.Ida, self.R0, self.sigma, self.Pbl, self.fexp)
def setUp(self): IMP.test.TestCase.setUp(self) #IMP.set_log_level(IMP.MEMORY) IMP.set_log_level(0) self.m = IMP.Model() self.q0 = Scale.setup_particle(IMP.Particle(self.m), 0.1) self.DA = IMP.DerivativeAccumulator() self.qmin = 0.01 self.qmax = 0.8 self.sq = 0.34 self.J = IMP.isd.SlidingPriorRestraint(self.q0, self.qmin, self.qmax, self.sq)
def test_GetSet2(self): "Test Scale get and set (border check)" scale = Scale.setup_particle(IMP.Particle(self.m), 50.0) scale.set_lower(10) scale.set_upper(80) for si in range(1,100): scale.set_scale(si) if si < 10: est = 10 elif si > 80: est = 80 else: est = si self.assertAlmostEqual(scale.get_scale(), est, delta=1e-6)
def test_GetSet2(self): "Test Scale get and set (border check)" scale = Scale.setup_particle(IMP.kernel.Particle(self.m), 50.0) scale.set_lower(10) scale.set_upper(80) for si in range(1, 100): scale.set_scale(si) if si < 10: est = 10 elif si > 80: est = 80 else: est = si self.assertAlmostEqual(scale.get_scale(), est, delta=1e-6)
def setUp(self): IMP.test.TestCase.setUp(self) #IMP.set_log_level(IMP.MEMORY) IMP.set_log_level(0) self.m = IMP.Model() #setup dihedral angle of pi/2 self.p0 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m), IMP.algebra.Vector3D(1,0,0)) self.p1 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m), IMP.algebra.Vector3D(0,0,0)) self.p2 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m), IMP.algebra.Vector3D(0,1,0)) self.p3 = IMP.core.XYZ.setup_particle(IMP.Particle(self.m), IMP.algebra.Vector3D(0,1,1)) #scale particle self.kappa = Scale.setup_particle(IMP.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() # 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.Model() self.n_sigmas = 20 self.lower=0.1 self.upper=100 self.sigmas = [Scale.setup_particle(IMP.Particle(self.m), 1.0+i) \ for i in xrange(self.n_sigmas)] for s in self.sigmas: s.set_lower(self.lower) s.set_upper(self.upper) self.J = [IMP.isd.JeffreysRestraint(s) for s in self.sigmas] for j in self.J: self.m.add_restraint(j) self.so=MaintainScaleOrderConstraint(self.sigmas) self.m.add_score_state(self.so)
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_Setup1(self): si = Scale.setup_particle(IMP.Particle(self.m)) self.assertAlmostEqual(float(si.get_scale()),1.0, delta=1e-6) self.assertAlmostEqual(float(si.get_lower()),0.0, delta=1e-6) self.assertFalse(si.has_upper()) self.assertTrue(math.isinf(si.get_upper()))
def test_Nuisance(self): "Test that a Nuisance can be converted to a Scale" n = Nuisance.setup_particle(IMP.kernel.Particle(self.m), 3.0) n.set_lower(0) self.assertTrue(Scale.get_is_setup(n.get_particle()))
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), 1.0)
def create_scale(m, v=None): p = IMP.Particle(m) if v is None: v = random.uniform(0, 50) return Scale.setup_particle(p, v)
def setUp(self): IMP.test.TestCase.setUp(self) #IMP.base.set_log_level(IMP.MEMORY) IMP.base.set_log_level(0) self.m = IMP.Model() self.sigma = Scale.setup_particle(IMP.Particle(self.m), 1.0)
def test_Nuisance(self): "Test that a Nuisance can be converted to a Scale" n=Nuisance.setup_particle(IMP.Particle(self.m),3.0) n.set_lower(0) self.assertTrue(Scale.particle_is_instance(n.get_particle()))