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 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.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.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()))
