def test_part1(self):
"""Test round trip 1"""
for suffix in [".rmfz", ".rmf3"]:
m = IMP.Model()
print("reading pdb")
h = IMP.atom.read_pdb(self.get_input_file_name("simple.pdb"), m,
IMP.atom.NonAlternativePDBSelector())
IMP.set_log_level(IMP.SILENT)
IMP.atom.add_bonds(h)
print("done")
IMP.set_log_level(IMP.VERBOSE)
print("writing hierarchy")
name = self.get_tmp_file_name("test_rt_parts" + suffix)
f = RMF.create_rmf_file(name)
print(f, type(f))
IMP.rmf.add_hierarchy(f, h)
IMP.rmf.save_frame(f, str(0))
del f
f = RMF.open_rmf_file_read_only(name)
print("reading")
print(f, type(f))
h2 = IMP.rmf.create_hierarchies(f, m)
self.assertEqual(len(h2), 1)
del f
m = IMP.Model()
print("reopening")
f = RMF.open_rmf_file_read_only(name)
print("reading")
h2 = IMP.rmf.create_hierarchies(f, m)
def test_perturbed(self):
"""Test reading and writing particles"""
for suffix in IMP.rmf.suffixes:
m = IMP.kernel.Model()
p0 = IMP.kernel.Particle(m)
p1 = IMP.kernel.Particle(m)
ik = IMP.IntKey("hi int")
fk = IMP.FloatKey("hi float")
p0.add_attribute(ik, 1)
p1.add_attribute(fk, 2.0)
p1.add_attribute(ik, 3)
name = self.get_tmp_file_name("particles" + suffix)
print(name)
rmf = RMF.create_rmf_file(name)
IMP.base.set_log_level(IMP.base.SILENT)
IMP.rmf.add_particles(rmf, [p0, p1])
IMP.rmf.save_frame(rmf, str(0))
del rmf
rmf = RMF.open_rmf_file_read_only(name)
bps = IMP.rmf.create_particles(rmf, m)
IMP.rmf.load_frame(rmf, RMF.FrameID(0))
# IMP.rmf.load_frame(0)
self.assertEqual(len(bps), 2)
bps[0].show()
self.assertTrue(bps[0].has_attribute(ik))
self.assertEqual(bps[0].get_value(ik), 1)
self.assertTrue(bps[1].has_attribute(ik))
self.assertEqual(bps[1].get_value(ik), 3)
self.assertTrue(bps[1].has_attribute(fk))
self.assertEqual(bps[1].get_value(fk), 2.0)
def test_0(self):
"""Test writing restraints rmf"""
RMF.set_log_level("Off")
for suffix in RMF.suffixes:
name=self.get_tmp_file_name("restr."+suffix)
self._write_restraint(name)
self._read_restraint(name)
def test_paths(self):
"""Test paths in a named RMF file"""
tmpdir = RMF._get_temporary_file_path('test_paths')
subdir = os.path.join(tmpdir, 'sub1', 'sub2')
os.makedirs(subdir)
rmf = RMF.create_rmf_file(os.path.join(subdir, 'test.rmf3'))
key = self.get_filename_key(rmf)
node, prov = self.make_test_node(rmf)
ap = os.path.join(tmpdir, 'foo.pdb')
prov.set_filename(ap)
if sys.platform == 'win32':
# On Windows, filenames are not altered
self.assertEqual(node.get_value(key), ap)
self.assertEqual(prov.get_filename(), ap)
else:
# On Mac/Linux, internally, a relative path should be stored
self.assertEqual(node.get_value(key), '../../foo.pdb')
# API should return an absolute path
self.assertEqual(prov.get_filename(), ap)
ap = os.path.join(subdir, 'foo.pdb')
prov.set_filename(ap)
if sys.platform == 'win32':
self.assertEqual(node.get_value(key), ap)
self.assertEqual(prov.get_filename(), ap)
else:
self.assertEqual(node.get_value(key), 'foo.pdb')
self.assertEqual(prov.get_filename(), ap)
del rmf
if sys.platform != 'win32':
shutil.rmtree(tmpdir)
def test_0(self):
"""Test writing restraint sets to rmf"""
fn=self.get_tmp_file_name("restsets.rmf")
f= RMF.create_rmf_file(fn)
m= IMP.Model()
p= IMP.Particle(m)
IMP.atom.Hierarchy.setup_particle(p)
IMP.atom.Mass.setup_particle(p, 1)
IMP.core.XYZR.setup_particle(p).set_radius(1)
IMP.rmf.add_hierarchies(f, [p]);
rs= IMP.RestraintSet(m, 1.0)
r= IMP._ConstRestraint(1, [p])
r.set_name("restraint")
rs.add_restraint(r)
rs.evaluate(False)
IMP.rmf.add_restraints(f, [rs])
IMP.rmf.save_frame(f, 0)
del f
f= RMF.open_rmf_file(fn)
hs= IMP.rmf.create_hierarchies(fn, m)
nrs= IMP.rmf.create_restraints(fn, m)
print nrs
self.assertEqual(len(nrs), 1)
rsnrs0= IMP.RestraintSet.get_from(nrs[0])
self.assertEqual(len(rsnrs0.get_restraints()), 1)
self.assertEqual(rsnrs0.get_name(), rs.get_name())
rb= rsnrs0.get_restraints()[0]
self.assertEqual(rb.evaluate(False), r.evaluate(False))
self.assertEqual(rb.get_name(), r.get_name())
def test_part1(self):
"""Test round trip 1"""
m= IMP.Model()
print "reading pdb"
h= IMP.atom.read_pdb(self.get_input_file_name("simple.pdb"), m,
IMP.atom.NonAlternativePDBSelector())
IMP.set_log_level(IMP.SILENT)
IMP.atom.add_bonds(h)
print "done"
IMP.set_log_level(IMP.VERBOSE)
print "writing hierarchy"
name=self.get_tmp_file_name("test_rt_parts.rmf")
f= RMF.create_rmf_file(name)
print f, type(f)
IMP.rmf.add_hierarchy(f, h)
del f
self.assertEqual( RMF.get_open_hdf5_handle_names(), [])
f= RMF.open_rmf_file_read_only(name)
print "reading"
print f, type(f)
h2=IMP.rmf.create_hierarchies(f, m)
self.assertEqual(len(h2), 1)
del f
m= IMP.Model()
print "reopening"
f= RMF.open_rmf_file_read_only(name)
print "reading"
h2=IMP.rmf.create_hierarchies(f, m)
def test_large(self):
"""Test multi frame files"""
IMP.set_log_level(IMP.VERBOSE)
RMF.set_log_level("trace")
suffixes = IMP.rmf.suffixes[:]
if '.rmf' not in suffixes:
suffixes.append('.rmf')
for suffix in suffixes:
m = IMP.Model()
p = IMP.Particle(m)
h = IMP.atom.Hierarchy.setup_particle(p)
d = IMP.core.XYZR.setup_particle(p)
md = IMP.atom.Mass.setup_particle(p, 1)
d.set_radius(1)
d.set_x(0)
d.set_y(0)
d.set_z(0)
nf = 10
path = self.get_tmp_file_name("test_mf" + suffix)
print(path)
f = RMF.create_rmf_file(path)
IMP.rmf.add_hierarchy(f, h)
for i in range(0, nf):
d.set_x(i)
IMP.rmf.save_frame(f, str(i))
del f
f = RMF.open_rmf_file_read_only(path)
[h] = IMP.rmf.create_hierarchies(f, m)
for i in range(0, nf):
IMP.rmf.load_frame(f, RMF.FrameID(i))
d = IMP.core.XYZR(h)
self.assertEqual(d.get_x(), i)
def test_large(self):
"""Test multi frame files"""
m= IMP.Model()
p =IMP.Particle(m)
h= IMP.atom.Hierarchy.setup_particle(p)
d= IMP.core.XYZR.setup_particle(p)
md= IMP.atom.Mass.setup_particle(p, 1)
d.set_radius(1)
d.set_x(0)
d.set_y(0)
d.set_z(0)
nf=10
IMP.set_log_level(IMP.VERBOSE)
f=RMF.create_rmf_file(self.get_tmp_file_name("test_mf.rmf"))
IMP.rmf.add_hierarchy(f, h)
for i in range(0,nf):
d.set_x(i)
IMP.rmf.save_frame(f, i)
del f
f= RMF.open_rmf_file(self.get_tmp_file_name("test_mf.rmf"))
[h]= IMP.rmf.create_hierarchies(f, m)
for i in range(0,nf):
IMP.rmf.load_frame( f, i)
d= IMP.core.XYZR(h)
self.assertEqual(d.get_x(), i)
def test_large(self):
"""Test multi frame files"""
for suffix in RMF.suffixes:
m = IMP.kernel.Model()
p = IMP.kernel.Particle(m)
h = IMP.atom.Hierarchy.setup_particle(p)
d = IMP.core.XYZR.setup_particle(p)
md = IMP.atom.Mass.setup_particle(p, 1)
d.set_radius(1)
d.set_x(0)
d.set_y(0)
d.set_z(0)
nf = 10
path = self.get_tmp_file_name("test_mf." + suffix)
print path
f = RMF.create_rmf_file(path)
IMP.rmf.add_hierarchy(f, h)
for i in range(0, nf):
d.set_x(i)
IMP.rmf.save_frame(f, i)
del f
f = RMF.open_rmf_file_read_only(path)
IMP.base.set_log_level(IMP.base.VERBOSE)
[h] = IMP.rmf.create_hierarchies(f, m)
for i in range(0, nf):
IMP.rmf.load_frame(f, i)
d = IMP.core.XYZR(h)
self.assertEqual(d.get_x(), i)
def test_2(self):
"""Test writing dynamic restraints"""
RMF.set_show_hdf5_errors(True)
f= RMF.create_rmf_file(self.get_tmp_file_name("dynamic_restraints.rmf"))
m= IMP.Model()
ps= [IMP.Particle(m) for i in range(0,10)]
ds= [IMP.core.XYZR.setup_particle(p) for p in ps]
for d in ds:
d.set_radius(1)
IMP.rmf.add_particles(f, ds)
cpc= IMP.container.ClosePairContainer(ps, 0)
r= IMP.container.PairsRestraint(IMP.core.SoftSpherePairScore(1), cpc)
bb= IMP.algebra.BoundingBox3D(IMP.algebra.Vector3D(0,0,0),
IMP.algebra.Vector3D(10,10,10))
r.set_model(m)
r.evaluate(False)
IMP.rmf.add_restraint(f, r)
scores=[]
for i in range(0,10):
for d in ds:
d.set_coordinates(IMP.algebra.get_random_vector_in(bb))
scores.append(r.evaluate(False))
IMP.rmf.save_frame(f, i)
for i,d in enumerate(ds):
d.set_x(i*10)
scores.append(r.evaluate(False))
IMP.rmf.save_frame(f, 10)
bps= IMP.rmf.create_particles(f, m)
rr= IMP.rmf.create_restraints(f, m)
print scores
for i in range(0,11):
IMP.rmf.load_frame(f, i)
print i
self.assertAlmostEqual(scores[i], rr[0].evaluate(False), delta=.01)
def test_some_rigid(self):
"""Test rigid body where children don't match members"""
for suffix in IMP.rmf.suffixes:
m = IMP.Model()
r = IMP.atom.Hierarchy.setup_particle(IMP.Particle(m))
r.set_name("rb")
tr = IMP.algebra.Transformation3D(
IMP.algebra.get_identity_rotation_3d(),
IMP.algebra.Vector3D(1,2,3))
rbd = IMP.core.RigidBody.setup_particle(r,
IMP.algebra.ReferenceFrame3D(tr))
ps = []
for i in range(0, 3):
p = IMP.Particle(m)
ps.append(p)
v = IMP.algebra.Vector3D(0, 0, 0)
v[i] = 1
d = IMP.core.XYZR.setup_particle(p)
d.set_coordinates(v)
d.set_radius(.5)
IMP.atom.Mass.setup_particle(p, .1)
r.add_child(IMP.atom.Hierarchy.setup_particle(p))
if i > 1: rbd.add_member(p)
fn = self.get_tmp_file_name("rigid" + suffix)
f = RMF.create_rmf_file(fn)
IMP.rmf.add_hierarchies(f, [r])
IMP.rmf.save_frame(f, str(0))
del f
# Reread RMF and make sure coordinates match
f = RMF.open_rmf_file_read_only(fn)
r2 = IMP.rmf.create_hierarchies(f, m)[0]
IMP.rmf.load_frame(f, RMF.FrameID(0))
new_ps = r2.get_children()
self.compare_coords(ps, new_ps, m)
def test_arrays(self):
"""Test arrays of integers"""
f= RMF.create_hdf5_file(self.get_tmp_file_name("testadg.hdf5"))
self._show(f)
print "adding"
ds= f.add_child_ints_data_set_2d("coords")
print "setting num"
ds.set_size([1,3])
ind=[0,1,2,3]
ds.set_value([0,0], ind)
ds.set_value([0,1], [4,5,6,7,8,9])
ds.set_size([2,3])
out=ds.get_value([0,0])
print out
print ds.get_value([0,1])
self.assertEqual(ind,out)
del ds
del f
f= RMF.open_hdf5_file(self.get_tmp_file_name("testadg.hdf5"))
ds= f.get_child_ints_data_set_2d("coords")
in2=ds.get_value([0,0])
in3=ds.get_value([1,1])
self.assertEqual(in2, out)
self.assertEqual(in3, [])
def test_frames(self):
"""Test creating a simple hierarchy file with frames"""
for suffix in RMF.suffixes:
path = RMF._get_temporary_file_path("test_file_frames." + suffix)
f = RMF.create_rmf_file(path)
f.add_frame("root", RMF.FRAME)
r = f.get_root_node()
print r.get_type()
sc = f.get_category("sequence")
ik = f.get_key(sc, "ik0", RMF.int_tag)
r.set_value(ik, 1)
self.assertEqual(r.get_value(ik), 1, 0)
f.add_frame("1", RMF.FRAME)
r.set_value(ik, 2)
del f
del sc
del ik
del r
f = RMF.open_rmf_file_read_only(path)
r = f.get_root_node()
sc = f.get_category("sequence")
ik = f.get_key(sc, "ik0", RMF.int_tag)
f.set_current_frame(RMF.FrameID(0))
self.assertEqual(r.get_value(ik), 1, 0)
f.set_current_frame(RMF.FrameID(1))
RMF.show_hierarchy_with_values(f.get_root_node())
self.assertEqual(r.get_value(ik), 2)
f.set_current_frame(RMF.FrameID(0))
self.assertEqual(r.get_value(ik), 1)
self.assertEqual(f.get_number_of_frames(), 2)
def _do_it(path):
fh = RMF.open_rmf_file_read_only(path)
mf = RMF.Molecule(fh)
cf = RMF.ChainFactory(fh)
res = RMF.get_resolutions(fh.get_root_node(), RMF.PARTICLE, .1)
if len(res) == 1:
res = [-1]
fh.set_current_frame(RMF.FrameID(0))
diameter = RMF.get_diameter(fh.get_root_node())
mydata = MyData(fh, diameter)
for f in fh.get_frames():
created = {}
fh.set_current_frame(f)
for r in res:
_create_molecules(
fh.get_root_node(),
mf,
cf,
mydata,
r,
created)
if len(created) == 0:
# fall back
_create_molecule(fh.get_root_node(), mydata, r, created)
for c in created:
cmd.load_model(created[c][1], c, f.get_index() + 1)
def test_part1(self):
"""Test round trip 1"""
for suffix in RMF.suffixes:
m= IMP.Model()
print "reading pdb"
h= IMP.atom.read_pdb(self.get_input_file_name("simple.pdb"), m,
IMP.atom.NonAlternativePDBSelector())
IMP.base.set_log_level(IMP.base.SILENT)
IMP.atom.add_bonds(h)
print "done"
IMP.base.set_log_level(IMP.base.VERBOSE)
print "writing hierarchy"
name=self.get_tmp_file_name("test_rt_parts."+suffix)
f= RMF.create_rmf_file(name)
print f, type(f)
IMP.rmf.add_hierarchy(f, h)
IMP.rmf.save_frame(f, 0)
del f
f= RMF.open_rmf_file_read_only(name)
print "reading"
print f, type(f)
h2=IMP.rmf.create_hierarchies(f, m)
self.assertEqual(len(h2), 1)
del f
m= IMP.Model()
print "reopening"
f= RMF.open_rmf_file_read_only(name)
print "reading"
h2=IMP.rmf.create_hierarchies(f, m)
def test_navigation(self):
"""Test loading and saving of rigid bodies"""
for suffix in RMF.suffixes:
m= IMP.kernel.Model()
r= IMP.atom.Hierarchy.setup_particle(IMP.kernel.Particle(m))
r.set_name("rb")
rbd= IMP.core.RigidBody.setup_particle(r, IMP.algebra.ReferenceFrame3D())
for i in range(0,3):
p = IMP.kernel.Particle(m)
v= IMP.algebra.Vector3D(0,0,0)
v[i]=1
d=IMP.core.XYZR.setup_particle(p)
d.set_coordinates(v)
d.set_radius(.5)
IMP.atom.Mass.setup_particle(p, .1)
r.add_child(IMP.atom.Hierarchy.setup_particle(p))
rbd.add_member(p)
for i in range(0,2):
p = IMP.kernel.Particle(m)
v= IMP.algebra.Vector3D(0,0,0)
v[i]=1
d=IMP.core.XYZR.setup_particle(p)
d.set_coordinates(v)
d.set_radius(.5)
IMP.atom.Mass.setup_particle(p, .1)
r.add_child(IMP.atom.Hierarchy.setup_particle(p))
rbd.add_non_rigid_member(p.get_index())
fn= self.get_tmp_file_name("rigid."+suffix)
f= RMF.create_rmf_file(fn)
IMP.rmf.add_hierarchies(f, [r])
IMP.rmf.save_frame(f, 0)
frames=[rbd.get_reference_frame()]
for i in range(0,10):
bb= IMP.algebra.get_unit_bounding_box_3d()
tr= IMP.algebra.Transformation3D(IMP.algebra.get_random_rotation_3d(),
IMP.algebra.get_random_vector_in(bb))
rf=IMP.algebra.ReferenceFrame3D(tr)
rbd.set_reference_frame(rf)
frames.append(rf)
m.update()
IMP.rmf.save_frame(f, i+1)
del f
f= RMF.open_rmf_file_read_only(fn)
IMP.rmf.link_hierarchies(f, [r])
print frames
for i in range(0,11):
IMP.rmf.load_frame(f, i)
print rbd.get_reference_frame()
for j, c in enumerate(r.get_children()):
oc= IMP.core.XYZ(c).get_coordinates()
m.update()
nc= IMP.core.XYZ(c).get_coordinates()
self.assertAlmostEqual((oc-nc).get_magnitude(), 0,
delta=.1)
if IMP.core.RigidMember.get_is_setup(c):
ic= IMP.core.RigidMember(c).get_internal_coordinates()
self.assertAlmostEqual(ic[j%3], 1, delta=.01)
else:
ic= IMP.core.NonRigidMember(c).get_internal_coordinates()
self.assertAlmostEqual(ic[j%3], 1, delta=.01)
def _read(self, name):
rmf = RMF.open_rmf_file_read_only(name)
rt = rmf.get_root_node()
print("children", rt.get_children())
c = rt.get_children()
print(-1, c)
c0 = c[0]
print(0, c0.get_children())
ref0 = c0.get_children()[0]
print("r0", ref0)
print(1, c0.get_children(), ref0)
print(rt.get_children()[0].get_children())
print(2)
ref1 = rt.get_children()[1].get_children()[0]
print("factory")
ef = RMF.ExternalFactory(rmf)
ref0d = ef.get(ref0)
path0 = ref0d.get_path()
print(path0)
self.assert_(os.path.exists(path0))
path1 = ref0d.get_path()
self.assert_(os.path.exists(path1))
self.assertEqual(path0, path1)
simple0 = open(path0, "r").read()
input = RMF._get_test_input_file_path("simple.pdb")
inputpdb = open(input, "r").read()
self.assertEqual(simple0, inputpdb)
def test_perturbed_frames(self):
"""Test reading and writing particles with frames"""
for suffix in RMF.suffixes:
m= IMP.kernel.Model()
p0= IMP.kernel.Particle(m)
p1= IMP.kernel.Particle(m)
ik= IMP.IntKey("hi int")
fk= IMP.FloatKey("hi float")
p0.add_attribute(ik, 1)
p1.add_attribute(fk, 2.0)
p1.add_attribute(ik, 3)
name= self.get_tmp_file_name("particles."+suffix)
print name
rmf= RMF.create_rmf_file(name)
IMP.base.set_log_level(IMP.base.SILENT)
IMP.rmf.add_particles(rmf, [p0, p1])
IMP.rmf.save_frame(rmf, 0)
p1.set_value(ik, 5)
IMP.rmf.save_frame(rmf, 1)
del rmf
rmf= RMF.open_rmf_file_read_only(name)
cat= rmf.get_category("IMP")
print cat
keys= rmf.get_keys(cat)
print [rmf.get_name(k) for k in keys]
bps= IMP.rmf.create_particles(rmf, m)
def test_frames(self):
"""Test creating a simple hierarchy file with frames"""
for suffix in RMF.suffixes:
path=RMF._get_temporary_file_path("test_file_frames."+suffix)
f= RMF.create_rmf_file(path)
r= f.get_root_node()
print r.get_type()
sc= f.get_category("sequence")
ik= f.get_int_key(sc, "ik0")
f0= f.get_root_frame().add_child("0", RMF.FRAME)
r.set_value(ik, 1)
self.assertEqual(r.get_value(ik), 1, 0)
f1= f0.add_child("1", RMF.FRAME)
r.set_value(ik, 2)
del f
del sc
del ik
del r
del f0
del f1
f= RMF.open_rmf_file_read_only(path)
r= f.get_root_node()
sc= f.get_category("sequence")
ik= f.get_int_key(sc, "ik0")
f.set_current_frame(0)
self.assertEqual(r.get_value(ik), 1, 0)
f.set_current_frame(1)
self.assertEqual(r.get_value(ik), 2)
f.set_current_frame(0)
self.assertEqual(r.get_value(ik), 1)
self.assertEqual(f.get_number_of_frames(), 2)
def test_gaussian_round_trip(self):
"""Make sure that Gaussians can be written to and read from RMFs"""
for suffix in IMP.rmf.suffixes:
m = IMP.kernel.Model()
r = IMP.atom.Hierarchy.setup_particle(IMP.kernel.Particle(m))
r.set_name("rt")
p = IMP.Particle(m)
v = IMP.algebra.Vector3D(1, 2, 3)
d = IMP.core.XYZR.setup_particle(p)
d.set_coordinates(v)
d.set_radius(.5)
IMP.atom.Mass.setup_particle(p, .1)
t = IMP.algebra.Transformation3D(
IMP.algebra.get_identity_rotation_3d(),
IMP.algebra.Vector3D(1,2,3))
IMP.core.Gaussian.setup_particle(p,IMP.algebra.Gaussian3D(
IMP.algebra.ReferenceFrame3D(t),[4,5,6]))
r.add_child(IMP.atom.Hierarchy.setup_particle(p))
fn = self.get_tmp_file_name("gaussian" + suffix)
f = RMF.create_rmf_file(fn)
IMP.rmf.add_hierarchies(f, [r])
IMP.rmf.save_frame(f, 0)
del f
f = RMF.open_rmf_file_read_only(fn)
prots = IMP.rmf.create_hierarchies(f, m)
g = IMP.core.Gaussian(prots[0].get_child(0))
self.assertEqual([v for v in g.get_variances()], [4,5,6])
self.assertAlmostEqual(IMP.core.XYZR(g).get_radius(), .5,
delta=1e-6)
self.assertAlmostEqual(IMP.atom.Mass(g).get_mass(), .1, delta=1e-6)
v = g.get_reference_frame().get_transformation_to()
v = v.get_translation()
self.assertEqual([i for i in v], [1,2,3])
def test_names(self):
"""Test if RMF can recall the molecule name and chain ID"""
for suffix in [".rmfz", ".rmf3"]:
for sequence in ('', 'CYW'):
m = IMP.Model()
h = IMP.atom.read_pdb(self.get_input_file_name("simple.pdb"), m,
IMP.atom.NonAlternativePDBSelector())
chs = IMP.atom.get_by_type(h, IMP.atom.CHAIN_TYPE)
chs[0].set_name('simple')
IMP.atom.Chain(chs[0]).set_sequence(sequence)
IMP.atom.Chain(chs[0]).set_chain_type(IMP.atom.Protein)
self.assertEqual(chs[0].get_name(), 'simple')
IMP.set_log_level(IMP.SILENT)
IMP.atom.add_bonds(h)
IMP.set_log_level(IMP.VERBOSE)
name = self.get_tmp_file_name("test_rt_parts" + suffix)
f = RMF.create_rmf_file(name)
IMP.rmf.add_hierarchy(f, h)
IMP.rmf.save_frame(f, str(0))
del f
f = RMF.open_rmf_file_read_only(name)
h2 = IMP.rmf.create_hierarchies(f, m)
del f
chs2 = IMP.atom.get_by_type(h2[0], IMP.atom.CHAIN_TYPE)
c = IMP.atom.Chain(chs2[0])
self.assertEqual(c.get_id(), 'A')
self.assertEqual(c.get_sequence(), sequence)
# Protein should be an alias for LPolypeptide
self.assertEqual(c.get_chain_type(), IMP.atom.Protein)
self.assertEqual(c.get_chain_type(), IMP.atom.LPolypeptide)
self.assertEqual(chs2[0].get_name(), 'simple')
def test_perturbed(self):
"""Test reading and writing particles"""
m= IMP.Model()
p0= IMP.Particle(m)
p1= IMP.Particle(m)
ik= IMP.IntKey("hi int")
fk= IMP.FloatKey("hi float")
p0.add_attribute(ik, 1)
p1.add_attribute(fk, 2.0)
p1.add_attribute(ik, 3)
name= self.get_tmp_file_name("particles.rmf")
rmf= RMF.create_rmf_file(name)
IMP.set_log_level(IMP.VERBOSE)
IMP.rmf.add_particles(rmf, [p0, p1])
IMP.rmf.save_frame(rmf, 0)
IMP.set_log_level(IMP.MEMORY)
onames= RMF.get_open_hdf5_handle_names()
print "before", onames
del rmf
IMP.set_log_level(IMP.VERBOSE)
onames= RMF.get_open_hdf5_handle_names()
print "closed", onames
self.assertEqual(len(onames), 0)
rmf= RMF.open_rmf_file_read_only(name)
bps= IMP.rmf.create_particles(rmf, m)
#IMP.rmf.load_frame(0)
self.assertEqual(len(bps), 2)
self.assertTrue(bps[0].has_attribute(ik))
self.assertEqual(bps[0].get_value(ik), 1);
self.assertTrue(bps[1].has_attribute(ik))
self.assertEqual(bps[1].get_value(ik), 3);
self.assertTrue(bps[1].has_attribute(fk))
self.assertEqual(bps[1].get_value(fk), 2.0);
def test_arrays_strings_1d(self):
"""Test strings data set"""
f= RMF.create_hdf5_file(self.get_tmp_file_name("testadgs1.hdf5"))
self._show(f)
print "adding"
ds= f.add_child_string_data_set_1d("strings")
print "setting num"
ds.set_size([1])
ind="0123"
ds.set_value([0], ind)
ds.set_size([2])
ds.set_value([1], "adfjhslak")
ds.set_size([3])
out=ds.get_value([0])
print out
print ds.get_value([1])
self.assertEqual(ind,out)
del ds
del f
f= RMF.open_hdf5_file(self.get_tmp_file_name("testadgs1.hdf5"))
ds= f.get_child_string_data_set_1d("strings")
in2=ds.get_value([0])
in3=ds.get_value([1])
self.assertEqual(in2, out)
self.assertEqual(in3, 'adfjhslak')
def test_ds(self):
"""Test low level usage of hdf5 with datasets"""
self._touch_all_types("datasets")
num_base_handles=RMF.get_number_of_open_hdf5_handles()
f= RMF.create_hdf5_file(self.get_tmp_file_name("testd.hdf5"))
self._show(f)
print "adding"
g= f.add_child_group("hi")
self._show(f)
ds= f.add_child_float_data_set_3d("x")
print "name is", ds.get_name()
self._show(f)
ds.set_size(I3(1,1,1))
ds.set_value(I3(0,0,0), 1)
print ds.get_value(I3(0,0,0))
self.assertEqual(ds.get_value(I3(0,0,0)), 1)
ds= f.add_child_string_data_set_3d("str")
self._show(f)
ds.set_size(I3(2,1,1))
ds.set_value([1,0,0],"there")
print ds.get_value([1,0,0])
self.assertEqual(ds.get_value(I3(1,0,0)), "there")
ds= f.add_child_int_data_set_3d("int")
self._show(f)
ds.set_size(I3(1,1,1))
ds.set_value(I3(0,0,0),1)
print ds.get_value(I3(0,0,0))
self.assertEqual(ds.get_value(I3(0,0,0)), 1)
del f
del g
del ds
self.assertEqual(RMF.get_number_of_open_hdf5_handles(), num_base_handles)
def test_3(self):
"""Test that simple pair restaints don't generate subnodes"""
m = IMP.kernel.Model()
def _cp(m, n):
pi = m.add_particle(n)
IMP.atom.Mass.setup_particle(m, pi, 1)
IMP.core.XYZR.setup_particle(
m,
pi,
IMP.algebra.get_unit_sphere_3d())
IMP.atom.Hierarchy.setup_particle(m, pi)
return pi
pi0 = _cp(m, "p0")
pi1 = _cp(m, "p1")
ps = IMP.core.SoftSpherePairScore(1)
path = self.get_tmp_file_name("pair_restraint.rmf3")
print(path)
rh = RMF.create_rmf_file(path)
particles = [m.get_particle(pi0), m.get_particle(pi1)]
IMP.rmf.add_hierarchies(rh, particles)
r = IMP.core.PairRestraint(ps, particles)
IMP.rmf.add_restraint(rh, r)
IMP.rmf.save_frame(rh, "frame")
rn = rh.get_root_node().get_children()[2]
RMF.show_hierarchy(rh.get_root_node())
self.assertEqual(rn.get_name(), r.get_name())
self.assertEqual([x for x in rn.get_children()], [])
def test_dsgrow(self):
"""Test low level usage of hdf5 with datasets that grow"""
self._touch_all_types("growing_datasets")
num_base_handles=RMF.get_number_of_open_hdf5_handles()
f= RMF.create_hdf5_file(self.get_tmp_file_name("testdg.hdf5"))
self._show(f)
print "adding"
g= f.add_child_group("hi")
self._show(f)
ds= f.add_child_float_data_set_3d("coords")
print "setting num"
ds.set_size([1,3,1])
print "setting values",[0,0,0]
ds.set_value([0,0,0], 1)
print "getting", [0,0,0]
print ds.get_value([0,0,0])
self.assertEqual(ds.get_value([0,0,0]), 1)
print "setting",0,2
ds.set_value([0,2,0], 2)
print "getting",0,2
print ds.get_value([0,2,0])
self.assertEqual(ds.get_value([0,2,0]), 2)
ds.set_size([4,5,6])
print "setting",3,4,5
ds.set_value([3,4,5], 4)
print "getting",3,4,5
print ds.get_value([3,4,5])
self.assertEqual(ds.get_value([3,4,5]), 4)
print "getting",1,1,1
print ds.get_value([1,1,1])
del ds
del f
del g
self.assertEqual(RMF.get_number_of_open_hdf5_handles(), num_base_handles)
def test_perturbed(self):
"""Test low level usage of hdf5"""
try:
import RMF_HDF5
except:
return
self._touch_all_types("pert")
num_base_handles = RMF.HDF5.get_number_of_open_handles()
f = RMF.HDF5.create_file(
RMF._get_temporary_file_path("test.hdf5"))
self._show(f)
print("adding")
g = f.add_child_group("hi")
ff = g.get_file()
self.assertEqual(ff.get_name(), f.get_name())
self._show(f)
del g
del f
del ff
self.assertEqual(
RMF.HDF5.get_number_of_open_handles(), num_base_handles)
f = RMF.HDF5.open_file(RMF._get_temporary_file_path("test.hdf5"))
print("showing")
self._show(f)
del f
self.assertEqual(
RMF.HDF5.get_number_of_open_handles(), num_base_handles)
def test_arrays_strings_1d(self):
"""Test strings data set 1d"""
try:
import RMF_HDF5
except:
return
f = RMF.HDF5.create_file(RMF._get_temporary_file_path("testadgs1.hdf5"))
self._show(f)
print "adding"
ds = f.add_child_string_data_set_1d("strings")
print "setting num"
ds.set_size([1])
ind = "0123"
ds.set_value([0], ind)
ds.set_size([2])
ds.set_value([1], "adfjhslak")
ds.set_size([3])
out = ds.get_value([0])
print out
print ds.get_value([1])
self.assertEqual(ind, out)
del ds
del f
f = RMF.HDF5.open_file(RMF._get_temporary_file_path("testadgs1.hdf5"))
ds = f.get_child_string_data_set_1d("strings")
in2 = ds.get_value([0])
in3 = ds.get_value([1])
self.assertEqual(in2, out)
self.assertEqual(in3, "adfjhslak")
def test_arrays(self):
"""Test arrays of integers"""
try:
import RMF_HDF5
except:
return
f = RMF.HDF5.create_file(RMF._get_temporary_file_path("testadg.hdf5"))
self._show(f)
print "adding"
ds = f.add_child_ints_data_set_2d("coords")
print "setting num"
ds.set_size([1, 3])
ind = [0, 1, 2, 3]
ds.set_value([0, 0], ind)
ds.set_value([0, 1], [4, 5, 6, 7, 8, 9])
ds.set_size([2, 3])
out = ds.get_value([0, 0])
print out
print ds.get_value([0, 1])
self.assertEqual(ind, list(out))
del ds
del f
f = RMF.HDF5.open_file(RMF._get_temporary_file_path("testadg.hdf5"))
ds = f.get_child_ints_data_set_2d("coords")
in2 = ds.get_value([0, 0])
in3 = ds.get_value([1, 1])
self.assertEqual(in2, out)
self.assertEqual(list(in3), [])
def test_3(self):
"""Testing surface geometry"""
for suffix in IMP.rmf.suffixes:
self.skipTest("surfaces not supported")
#self.skipTest("surface geometry is disabled")
g = IMP.algebra.DenseDoubleGrid3D(
1, IMP.algebra.BoundingBox3D((-10, -10, -10),
(10, 10, 10)))
for i in g.get_all_indexes():
c = g.get_center(i)
m = c.get_magnitude()
g[i] = 100 - m
# for i in g.get_all_indexes():
# print i, g.get_center(i), g[i]
gg = IMP.display.IsosurfaceGeometry(g, 95.0)
gg.set_name("isosurface")
rmf = RMF.create_rmf_file(self.get_tmp_file_name("iso" + suffix))
IMP.rmf.add_geometry(rmf, gg)
del rmf
rmf = RMF.open_rmf_file(self.get_tmp_file_name("iso" + suffix))
gs = IMP.rmf.create_geometries(rmf)
w = IMP.display.PymolWriter(self.get_tmp_file_name("iso.pym"))
w.add_geometry(gg)
gs[0].set_name("after")
w.add_geometry(gs[0])
def add_rmf(self, rmf_fn, nframe):
"""Add selections from an RMF file"""
print('reading from RMF file', rmf_fn)
rh = RMF.open_rmf_file_read_only(rmf_fn)
prots = IMP.rmf.create_hierarchies(rh, self.model)
hier = prots[0]
IMP.rmf.load_frame(rh, RMF.FrameID(0))
ps_per_component = defaultdict(list)
if self.num_rmf == 0:
self.size_per_component = defaultdict(int)
self.model.update()
# gathers particles for all components
part_dict = IMP.pmi.analysis.get_particles_at_resolution_one(hier)
all_particles_by_resolution = []
for name in part_dict:
all_particles_by_resolution += part_dict[name]
for component_name in self.selections:
for seg in self.selections[component_name]:
if type(seg) == str:
s = IMP.atom.Selection(hier, molecule=seg)
elif type(seg) == tuple:
s = IMP.atom.Selection(hier,
molecule=seg[2],
residue_indexes=range(
seg[0], seg[1] + 1))
else:
raise Exception('could not understand selection tuple ' +
str(seg))
parts = list(
set(s.get_selected_particles())
& set(all_particles_by_resolution))
ps_per_component[component_name] += IMP.get_indexes(parts)
if self.num_rmf == 0:
self.size_per_component[component_name] += \
sum(len(IMP.pmi.tools.get_residue_indexes(p))
for p in parts)
for n1, name1 in enumerate(self.names):
for name2 in self.names[n1 + 1:]:
ncontacts = len(
self.gcpf.get_close_pairs(self.model,
ps_per_component[name1],
ps_per_component[name2]))
if ncontacts > 0:
self.edges[tuple(sorted((name1, name2)))] += 1.0
self.num_rmf += 1
def readTrajectories(self):
cgFileName = self.getParam("cg_output_file")
bestCgScore = 10000000
bestCgScoreFile = ""
bestCgRmsd = 10000000
bestCgRmsdFile = ""
outputDir = self.getParam("output_directory")
trajectoryFile = self.getParam("md_trajectory_output_file")
fullFile = os.path.join(outputDir, trajectoryFile)
rh = RMF.open_rmf_file(fullFile)
IMP.rmf.set_hierarchies(rh, [self.protein])
framesToRead = atomicDominoUtilities.getMdIntervalFrames(
rh, int(self.getParam("cg_interval")), self.protein)
if (len(framesToRead) > 0):
for cgNumber in framesToRead:
# Open next cg trajectory
outputDir = self.getParam("output_directory")
fullCgFileName = os.path.join(outputDir,
"%s%s" % (cgFileName, cgNumber))
rh = RMF.open_rmf_file(fullCgFileName)
IMP.rmf.set_hierarchies(rh, [self.protein])
frameCount = IMP.rmf.get_number_of_frames(rh, self.protein)
IMP.rmf.load_frame(rh, frameCount - 1, self.protein)
score = self.model.evaluate(False)
rmsd = self.calculateNativeRmsd(self.flexibleAtoms)
print("cg number %s has score %s rmsd %s" %
(cgNumber, score, rmsd))
if (score < bestCgScore):
bestCgScore = score
bestCgScoreFile = fullCgFileName
if (rmsd < bestCgRmsd):
bestCgRmsd = rmsd
bestCgRmsdFile = fullCgFileName
# output best score information
self.singlePdbResults(bestCgScoreFile, -1,
self.getParam("best_cg_score_output_file"))
self.singlePdbResults(bestCgRmsdFile, -1,
self.getParam("best_cg_rmsd_output_file"))
self.singlePdbResults("%s%s" % (cgFileName, framesToRead[-1]), -1,
self.getParam("final_cg_frame_output_file"))
finalCgRmsd = self.calculateNativeRmsd(self.flexibleAtoms)
self.bestCgScore = bestCgScore
self.bestCgRmsd = bestCgRmsd
self.finalCgRmsd = finalCgRmsd
def test_rt(self):
"""Test that provenance info can be stored in RMF files"""
for suffix in [".rmfz", ".rmf3"]:
m = IMP.Model()
name = self.get_tmp_file_name("test_provenance" + suffix)
h = IMP.atom.read_pdb(self.get_input_file_name("simple.pdb"), m,
IMP.atom.NonAlternativePDBSelector())
self.add_provenance(h)
f = RMF.create_rmf_file(name)
IMP.rmf.add_hierarchy(f, h)
IMP.rmf.save_frame(f, "0")
del f
f = RMF.open_rmf_file_read_only(name)
h2 = IMP.rmf.create_hierarchies(f, m)
self.check_provenance(h2[0])
def _set_cylinder(cylinder_descriptor, cf, ipf):
"""
draws a cylinder between two nodes with refframes
cylinder descriptor - tuple (cylinder_node, node1, node2)
cf - cylinder factory
ipf - intermediate particle factory
"""
nh = cylinder_descriptor[0]
ep0 = cylinder_descriptor[1]
ep1 = cylinder_descriptor[2]
cep0 = ipf.get(ep0).get_translation()
cep1 = ipf.get(ep1).get_translation()
coords_list = [RMF.Vector3(cep0), RMF.Vector3(cep1)]
# coords=[[cep0[0], cep1[0]], [cep0[1], cep1[1]], [cep0[2], cep1[2]]]
cf.get(nh).set_frame_coordinates_list(coords_list)
def test_new_node_type(self):
"""Make sure we can read RMF files with node types that are new to us"""
# This file was created by adding
# const NodeType BIGTYPE(99, "big type");
# to src/enums.cpp, rebuilding RMF, then creating a simple file with
# fh = RMF.create_rmf_file("test.rmf3")
# fh.add_frame('zero', RMF.FRAME)
# rt = fh.get_root_node()
# c0 = rt.add_child("c0", RMF.BIGTYPE)
fname = RMF._get_test_input_file_path("new-node-type.rmf3")
fh = RMF.open_rmf_file_read_only(fname)
rt = fh.get_root_node()
c0, = rt.get_children()
# Unknown node types should be mapped to the invalid type
self.assertEqual(c0.get_type(), RMF.INVALID_NODE_TYPE)
def test_traverse(self):
"""Test TraverseHelper"""
path = RMF._get_test_input_file_path("simple-new.rmf")
f = RMF.open_rmf_file_read_only(path)
f.set_current_frame(RMF.FrameID(0))
t = RMF.TraverseHelper(f.get_root_node(), "testmol")
self.assertEqual(t.get_chain_id(), None)
self.assertEqual(t.get_residue_index(), None)
self.assertEqual(t.get_residue_type(), None)
# self.assertEqual(t.get_molecule_name(), "testmol")
self.assertEqual(t.get_rgb_color(), None)
self.assertEqual(t.get_state_index(), 0)
self.assertEqual(t.get_copy_index(), None)
# self.assertEqual(t.get_global_coordinates(RMF.Vector3(0,0,0)), None)
self.assertEqual(len(t.get_children()), 1)
def test_cone_construction(self):
"""Check linear well"""
m = IMP.Model()
m.set_log_level(IMP.SILENT)
ds = [self._create_diffuser(m) for i in range(0, 2)]
dsi = [x.get_particle_index() for x in ds]
ds[1].set_coordinates(IMP.algebra.Vector3D(0, 2 * radius, 0))
rest_length_factor = 1.0
k = 20
ps = IMP.npctransport.LinearWellPairScore(rest_length_factor, k)
r = IMP.core.PairRestraint(m, ps, dsi)
bd = IMP.atom.BrownianDynamicsTAMD(m)
bd.set_maximum_time_step(100)
bd.set_scoring_function([r])
f = RMF.create_rmf_file(self.get_tmp_file_name("well.rmf"))
# TODO: note that if ds would have contained sites, we would
# need to switch to npctransport::add_hierarchies_with_sites(),
# perhaps worth switching anyway?
IMP.rmf.add_hierarchies(f, ds)
IMP.rmf.add_restraints(f, [r])
w = IMP.rmf.SaveOptimizerState(m, f)
w.set_period(100) # set this to one only for debugging
bd.add_optimizer_state(w)
bd.optimize(1000)
dist = IMP.core.get_distance(ds[0], ds[1])
print(dist)
self.assertAlmostEqual(dist, 0, delta=radius)
def _touch_all_types(self, nm):
"""touch all types so all static hids are created"""
print("touching")
f = RMF.HDF5.create_file(
RMF._get_temporary_file_path(nm + "_types.hdf5"))
self._do_touch_types(f, False)
print("done touching")
def test_dsb(self):
"""Test writing of blocks with data sets"""
try:
import RMF_HDF5
except:
return
self._touch_all_types("block_datasets")
num_base_handles = RMF.HDF5.get_number_of_open_handles()
f = RMF.HDF5.create_file(RMF._get_temporary_file_path("testdb.hdf5"))
self._show(f)
print("adding")
g = f.add_child_group("hi")
self._show(f)
ds = f.add_child_index_data_set_3d("x")
print("name is", ds.get_name())
self._show(f)
ds.set_size(I3(10, 10, 10))
ds.set_block(I3(2, 3, 4), I3(3, 4, 5), range(0, 3 * 4 * 5))
got = ds.get_block(I3(2, 3, 4), I3(3, 4, 5))
self.assertEqual(list(got), list(range(0, 3 * 4 * 5)))
del g
del f
del ds
self.assertEqual(RMF.HDF5.get_number_of_open_handles(),
num_base_handles)
def get_conforms_per_frame_batch(arg_bundle):
rmf_file, frames, mod_id_start = arg_bundle[:3]
resolution, subunit_name, selection, path = arg_bundle[3:]
from collections import defaultdict
m = IMP.Model()
rmf_fh = RMF.open_rmf_file_read_only(os.path.join(path, rmf_file))
h = IMP.rmf.create_hierarchies(rmf_fh, m)[0]
result = defaultdict(list)
mod_id = mod_id_start
for f in frames:
IMP.rmf.load_frame(rmf_fh, f)
m.update()
if subunit_name:
s0 = IMP.atom.Selection(h, resolution=resolution,
molecule=subunit_name)
elif selection is not None:
s0 = parse_rmsd_selection(h, selection, resolution)
else:
s0 = IMP.atom.Selection(h, resolution=resolution)
particles = s0.get_selected_particles()
# Copy particle coordinates
for i in range(len(particles)):
# i is an index over all particles in the system
leaf = particles[i]
p = IMP.core.XYZR(leaf)
pxyz = p.get_coordinates()
result[mod_id].append(list(pxyz))
mod_id += 1
return result
def test_write_multistate(self):
"""Test you write multistate system with correct hierarchy"""
model = IMP.Model()
s = IMP.pmi.topology.System(model)
seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('seqs.fasta'))
st1 = s.create_state()
m1 = st1.create_molecule("Prot1",sequence=seqs["Protein_1"])
atomic_res = m1.add_structure(self.get_input_file_name('prot.pdb'),
chain_id='A',res_range=(55,63),offset=-54)
m1.add_representation(atomic_res,resolutions=0)
st2 = s.create_state()
m2 = st2.create_molecule("Prot1",sequence=seqs["Protein_1"])
atomic_res = m2.add_structure(self.get_input_file_name('prot.pdb'),
chain_id='A',res_range=(55,63),offset=-54)
m2.add_representation(atomic_res,resolutions=0)
root_hier = s.build()
rex = IMP.pmi.macros.ReplicaExchange0(model,
root_hier=root_hier,
number_of_frames=0,
number_of_best_scoring_models=0,
global_output_directory='multistate_test/')
rex.execute_macro()
rh2 = RMF.open_rmf_file_read_only('multistate_test/initial.0.rmf3')
hs = IMP.rmf.create_hierarchies(rh2,model)
self.assertEqual(len(hs),1)
states = IMP.atom.get_by_type(hs[0],IMP.atom.STATE_TYPE)
self.assertEqual(len(states),2)
def run_analysis_step(self):
"""Run the analysis part of the modeling"""
os.chdir(self.test_dir)
os.mkdir('ANALYSIS')
os.mkdir('ANALYSIS/DATA')
os.mkdir('RMF')
# Get all needed input files
shutil.copy('SAMPLING/BIAS', 'ANALYSIS/DATA')
shutil.copy('%s/config_files/test/analysis/config.ini' % TOPDIR,
'ANALYSIS/DATA')
self._get_shared_inputs('ANALYSIS/DATA')
self._get_inputs('analysis', 'ANALYSIS/DATA')
# Run analysis script
subprocess.check_call(
["%s/scripts/analysis/test_analysis.sh" % TOPDIR])
# Make sure expected files were produced
for i in range(1000):
for fname in ('fret.dat', 'log.dat'):
self.assertTrue(
os.path.exists(
os.path.join('ANALYSIS', 'frame_%d' % i, fname)))
for (prefix, toplevel_children) in (('frame', 609), ('frameisd',
15)):
fname = os.path.join('RMF', '%s_%d.rmf' % (prefix, i))
r = RMF.open_rmf_file_read_only(fname)
self._check_rmf_file(r,
frames=1,
toplevel_children=toplevel_children)
def test_round_trip(self):
"""Test that exceptions are transformed"""
m = IMP.kernel.Model()
rmf = RMF.create_rmf_file(self.get_tmp_file_name("zillion.rmf"))
h = IMP.atom.Fragment.setup_particle(IMP.kernel.Particle(m))
IMP.core.XYZR.setup_particle(h)
IMP.atom.Mass.setup_particle(h, 1)
IMP.rmf.add_hierarchies(rmf, [h])
print 'saving 0'
IMP.rmf.save_frame(rmf, "zero")
print 'loading bad'
self.assertRaises(
IMP.base.IOException,
IMP.rmf.load_frame,
rmf,
RMF.FrameID(6))
def test_data_types(self):
"""Test external file references"""
RMF.set_log_level("trace")
for suffix in RMF.suffixes:
name = RMF._get_temporary_file_path("externals." + suffix)
print(name)
input = RMF._get_test_input_file_path("simple.pdb")
inputpdb = open(input, "r").read()
tdir = os.path.split(name)[0]
sfile = os.path.join(tdir, "simple.pdb")
open(sfile, "w").write(inputpdb)
print("create")
self._create(name, sfile)
print("read")
self._read(name)
print("done")
def _recolor(node, tf, cf, types, color):
children = node.get_children()
if tf.get_is(node):
node_type_name = tf.get(node).get_type_name()
if node_type_name in types:
cd = cf.get(node)
cd.set_static_rgb_color(RMF.Vector3(color[0], color[1], color[2]))
subtypes = set()
for c in children:
if not tf.get_is(c):
continue
c_type_name = tf.get(c).get_type_name()
if re.match(node_type_name, c_type_name):
subtypes.add(c_type_name)
nst = len(subtypes)
subtype2color = {}
for i, subtype in enumerate(subtypes):
scale = (i + 1.0) / nst
subtype2color[subtype] = [scale * x for x in color]
# print("recolor", subtype, i, scale, subtype2color[subtype])
# print("subtype2color", subtype2color)
for c in children:
if not tf.get_is(c):
continue
c_subtype = tf.get(c).get_type_name()
# print("Color", c_subtype, " in ", subtype2color[c_subtype])
_recolor(c, tf, cf, [c_subtype], subtype2color[c_subtype])
return
for c in children:
# print "recolor",c,color
_recolor(c, tf, cf, types, color)
def test_perturbed_values_0(self):
"""Test null values int"""
for suffix in RMF.suffixes:
path = RMF._get_temporary_file_path("test_filei." + suffix)
f = RMF.create_rmf_file(path)
r = f.get_root_node()
print(r.get_type())
sc = f.get_category("sequence")
ik = f.get_key(sc, "ik0", RMF.int_tag)
f.add_frame("0", RMF.FRAME)
r.set_frame_value(ik, 1)
ika = r.get_value(ik)
self.assertEqual(ika, 1)
f1 = f.add_frame("1", RMF.FRAME)
ikna = r.get_value(ik)
self.assertEqual(ikna, None)
def _test_one(self, site_range, site_k, nonspec_range, nonspec_k,
soft_sphere_k, dt):
m = IMP.Model()
m.set_log_level(IMP.SILENT)
ds = [self._create_particle(m) for i in range(0, 2)]
ds[0].set_coordinates(IMP.algebra.Vector3D(0, 0, 0))
ds[1].set_coordinates(IMP.algebra.Vector3D(2 * radius, 0, 0))
types = [IMP.core.ParticleType(d.get_name() + " type") for d in ds]
for d in zip(types, ds):
IMP.core.Typed.setup_particle(d[1], d[0])
sites = ([IMP.algebra.Vector3D(radius, 0, 0)],
[IMP.algebra.Vector3D(-radius, 0, 0)])
ps = IMP.npctransport.SitesPairScore(site_range, site_k, nonspec_range,
nonspec_k, soft_sphere_k,
sites[0], sites[1])
ps.set_log_level(IMP.VERBOSE)
r = IMP.core.PairRestraint(ps, ds)
m.add_restraint(r)
bd = IMP.atom.BrownianDynamics(m)
bd.set_maximum_time_step(dt)
f = RMF.create_rmf_file(self.get_tmp_file_name("glue.rmf"))
for d in zip(types, sites):
IMP.npctransport.add_sites(f, d[0], .5 * radius, d[1])
w = IMP.npctransport.add_hierarchies_with_sites(f, ds)
sos = IMP.rmf.SaveOptimizerState(f)
bd.add_optimizer_state(sos)
sos.set_period(1000)
bd.optimize(1000)
sos.update_always()
def add_coordinates(self, key, name, format='raw', append=True,
extension='pdb', hierarchies=None, restraints=None):
"""adds a placeholder for coordinates
- format = rmf3:
will write the whole system as provided, in rmf3 format
- hierarchies must contain protein hierarchies
- restraints is a list of restraints
- format = raw:
will write provided data as-is
- append: whether to append to a trajectory or to write multiple
files. With this format, a trajectory is just a string, you can
stuff whatever you want in it. If append is False, files will be
numbered according to the counter of their category.
- extension: the file extension to use
"""
if not key in self.categories:
raise ValueError("unknown category: %s" % key)
self.categories[key][name] = None
if format == 'raw':
self.coordinates.append((key, name, 'raw', (append, extension)))
elif format == 'rmf3':
import RMF
import IMP.rmf
assert hierarchies is not None
rh = RMF.create_rmf_file(self.prefix + '_' + name + '_traj.rmf3')
IMP.rmf.add_hierarchies(rh, hierarchies)
if restraints:
IMP.rmf.add_restraints(rh, restraints)
self.coordinates.append((key, name, 'rmf3', rh))
else:
raise ValueError("format can only be rmf3 or raw")
def _write_restraint(self, name, cls=IMP._ConstRestraint, extra_ps=0):
f = RMF.create_rmf_file(name)
m = IMP.Model()
p = IMP.Particle(m)
IMP.rmf.add_particles(f, [p])
ps = [p]
# extra_ps are particles referenced by the restraint but not
# explicitly added to the RMF
if extra_ps:
p1 = IMP.Particle(m, "extra0")
IMP.atom.Mass.setup_particle(p1, 42.0)
p2 = IMP.Particle(m, "extra1")
IMP.core.XYZ.setup_particle(p2, IMP.algebra.Vector3D(1, 2, 3))
IMP.core.XYZR.setup_particle(p2, 4)
p3 = IMP.Particle(m, "extra2")
g = IMP.core.Gaussian.setup_particle(p3)
g.set_variances([106.783, 55.2361, 20.0973])
rot = IMP.algebra.Rotation3D(
[0.00799897, 0.408664, -0.845514, -0.343563])
tran = IMP.algebra.Vector3D(101.442, 157.066, 145.694)
tr = IMP.algebra.Transformation3D(rot, tran)
g.set_reference_frame(IMP.algebra.ReferenceFrame3D(tr))
p4 = IMP.Particle(m, "extra3")
scale = IMP.isd.Scale.setup_particle(p4, 1.0)
scale.set_lower(0.0)
scale.set_upper(10.0)
ps.extend([p1, p2, p3, p4])
r = cls(1, ps)
r.evaluate(False)
IMP.rmf.add_restraint(f, r)
IMP.rmf.save_frame(f, str(0))
if extra_ps:
scale.set_scale(0.5)
IMP.rmf.save_frame(f, str(1))
def test_no_match_hierarchy(self):
"""Test rigid body that does not match the hierarchy"""
for suffix in IMP.rmf.suffixes:
m = IMP.Model()
top = IMP.atom.Hierarchy.setup_particle(IMP.Particle(m))
top.set_name("top")
tr = IMP.algebra.Transformation3D(
IMP.algebra.get_identity_rotation_3d(),
IMP.algebra.Vector3D(1, 2, 3))
rbd = IMP.core.RigidBody.setup_particle(
IMP.Particle(m), IMP.algebra.ReferenceFrame3D(tr))
for child in range(2):
r = IMP.atom.Hierarchy.setup_particle(IMP.Particle(m))
r.set_name("r%d" % child)
top.add_child(r)
for i in range(0, 3):
p = IMP.Particle(m)
v = IMP.algebra.Vector3D(0, 0, 0)
v[i] = 1
d = IMP.core.XYZR.setup_particle(p)
d.set_coordinates(v)
d.set_radius(.5)
IMP.atom.Mass.setup_particle(p, .1)
r.add_child(IMP.atom.Hierarchy.setup_particle(p))
if i > 1: rbd.add_member(p)
fn = self.get_tmp_file_name("rigid" + suffix)
f = RMF.create_rmf_file(fn)
IMP.rmf.add_hierarchies(f, [top])
IMP.rmf.save_frame(f, str(0))
del f
def _check_scale_node(self, rmf, node):
scalef = RMF.ScaleFactory(rmf)
self.assertTrue(scalef.get_is(node))
scale = scalef.get(node)
self.assertAlmostEqual(scale.get_scale(), 1.0, delta=1e-6)
self.assertAlmostEqual(scale.get_upper(), 10.0, delta=1e-6)
self.assertAlmostEqual(scale.get_lower(), 0.0, delta=1e-6)
def applyCg(self, mdStepStart, cgFileName):
cgSteps = int(self.getParam("cg_steps"))
# load md step specified by calling object
print("apply cg: loading md frame for cg step start %s" % mdStepStart)
IMP.rmf.load_frame(self.rootHandle, mdStepStart, self.protein)
# create new hdf5 file to which cg output will be written
outputDir = self.getParam("output_directory")
fileName = os.path.join(outputDir, cgFileName)
print("creating cg hdf5 file %s" % fileName)
rh = RMF.create_rmf_file(fileName)
my_kc = rh.add_category("my data")
IMP.rmf.add_hierarchy(rh, self.protein)
# apply cg
cg = IMP.core.ConjugateGradients(self.model)
firstScore = self.model.evaluate(False)
print("creating optimizer state")
hdos = IMP.rmf.SaveHierarchyConfigurationOptimizerState([self.protein],
rh)
hdos.set_skip_steps(0)
# hdos is the optimizer state writing configurations to disk
cg.add_optimizer_state(hdos)
print("running cg")
cg.optimize(cgSteps)
secondScore = self.model.evaluate(False)
print("cg score after md step %s before %s after %s" %
(mdStepStart, firstScore, secondScore))
return secondScore
def _add_nodes(node, cf, cdf, tf, types, radius, color, depth=0):
'''
node - rmf node to scan
cf - cylinder factory
cdf - colored factory
tf - typed factory
types - list of type names for which to apply method
'''
children = node.get_children()
ret = []
#print "inspecting", node.get_name()
if len(children) == 0:
return ret
if has_depth_with_site(node, 3) and tf.get_is(children[0]):
# search for any node that begins with tf_type (e.g. Nup100 -> Nup100_anchor, Nup100s, etc.)
# tf_type = tf.get(children[0]).get_type_name()
tf_type = tf.get(node).get_type_name()
# tf_type_matches= filter(lambda x : re.match(x, tf_type), types)
# assert(len(tf_type_matches)<=1) # something weird happen if matches more than one FG type
if (tf_type in types):
# print(tf_type,"matches")
for i in range(0, len(children) - 1):
cyl = node.add_child("cylinder", RMF.GEOMETRY)
cdf.get(cyl).set_static_rgb_color(
RMF.Vector3(color[0], color[1], color[2]))
ret.append((cyl, children[i], children[i + 1]))
# print "adding for", ret[-1], "depth", depth, "d3under?", has_depth_with_site(node, 3)
cf.get(cyl).set_radius(radius)
for c in children:
ret += _add_nodes(c, cf, cdf, tf, types, radius, color, depth + 1)
return ret
def _do_test(self, suffix):
"""Test creating a simple hierarchy file with multiple keys"""
f = RMF.create_rmf_file(
RMF._get_temporary_file_path("multikey." + suffix))
f.add_frame("0", RMF.FRAME)
r = f.get_root_node()
print(r.get_type())
sc = f.get_category("multikey")
ikfp = f.get_key(sc, "ik0", RMF.int_tag)
ik = f.get_key(sc, "ik0", RMF.int_tag)
on = r.add_child("oc", RMF.REPRESENTATION)
f.add_frame("1", RMF.FRAME)
r.set_value(ikfp, 1)
on.set_value(ik, 10)
print(r.get_value(ikfp))
print(on.get_value(ik))
def _test_three(self, site_range, site_k, nonspec_range, nonspec_k,
soft_sphere_k, dt):
m = IMP.Model()
m.set_log_level(IMP.SILENT)
ds = [self._create_particle(m) for i in range(0, 4)]
ds[0].set_coordinates(IMP.algebra.Vector3D(0, 0, 0))
ds[1].set_coordinates(IMP.algebra.Vector3D(2 * radius, 0, 0))
ds[2].set_coordinates(IMP.algebra.Vector3D(0, 0, 2 * radius))
ds[3].set_coordinates(IMP.algebra.Vector3D(2 * radius, 0, 2 * radius))
types = [IMP.core.ParticleType(d.get_name() + " type") for d in ds]
for d in zip(types, ds):
IMP.core.Typed.setup_particle(d[1], d[0])
f = RMF.create_rmf_file(self.get_tmp_file_name("glue3.rmf"))
rs = self._create_restraint_three(m, ds, site_range, site_k,
nonspec_range, nonspec_k,
soft_sphere_k, f)
bd = IMP.atom.BrownianDynamics(m)
bd.set_scoring_function(rs)
bd.set_maximum_time_step(dt)
w = IMP.npctransport.add_hierarchies_with_sites(f, ds)
IMP.rmf.add_restraints(f, rs)
sos = IMP.rmf.SaveOptimizerState(f)
sos.set_period(1000)
bd.add_optimizer_state(sos)
print "optimizin"
IMP.set_log_level(IMP.SILENT)
bd.optimize(3000)
print "done"
sos.update_always()
def test_set_coordinates_from_rmf(self):
mdl = IMP.Model()
s = IMP.pmi.topology.System(mdl)
seqs = IMP.pmi.topology.Sequences(
self.get_input_file_name('seqs.fasta'))
st1 = s.create_state()
m1 = st1.create_molecule("Prot1", sequence=seqs["Protein_1"])
a1 = m1.add_structure(self.get_input_file_name('prot.pdb'),
chain_id='A',
res_range=(55, 63),
offset=-54)
m1.add_representation(a1, resolutions=[0, 1])
m1.add_representation(m1.get_residues() - a1, resolutions=1)
hier = s.build()
sel = IMP.atom.Selection(
hier,
resolution=IMP.atom.ALL_RESOLUTIONS).get_selected_particles()
orig_coords = [IMP.core.XYZ(p).get_coordinates() for p in sel]
fname = self.get_tmp_file_name('test_set_coords.rmf3')
rh = RMF.create_rmf_file(fname)
IMP.rmf.add_hierarchy(rh, hier)
IMP.rmf.save_frame(rh)
del rh
for p in sel:
IMP.core.transform(IMP.core.XYZ(p),
IMP.algebra.Transformation3D([10, 10, 10]))
coords1 = [IMP.core.XYZ(p).get_coordinates() for p in sel]
for c0, c1 in zip(orig_coords, coords1):
self.assertNotEqual(IMP.algebra.get_distance(c0, c1), 0.0)
IMP.pmi.tools.set_coordinates_from_rmf(hier, fname, 0)
coords2 = [IMP.core.XYZ(p).get_coordinates() for p in sel]
for c0, c2 in zip(orig_coords, coords2):
self.assertAlmostEqual(IMP.algebra.get_distance(c0, c2), 0.0)
def visit(node, reference_frame, reference_frame_factory, particle_factory,
segment_factory, ball_factory):
if reference_frame_factory.get_is(node):
reference_frame = RMF.CoordinateTransformer(
reference_frame, reference_frame_factory.get(node))
print("reference frame is now", reference_frame)
elif segment_factory.get_is(node):
segment = segment_factory.get(node)
print("segment", node.get_name())
# silliness
coords = segment.get_coordinates()
for i in range(0, len(coords[0])):
print_coordinates(reference_frame,
[coords[0][i], coords[1][i], coords[2][i]])
elif particle_factory.get_is(node):
particle = particle_factory.get(node)
print("particle", node.get_name(),
print_coordinates(reference_frame, particle.get_coordinates()))
elif ball_factory.get_is(node):
particle = ball_factory.get(node)
print("ball", node.get_name(),
print_coordinates(reference_frame, particle.get_coordinates()))
for c in node.get_children():
visit(c, reference_frame, reference_frame_factory, particle_factory,
segment_factory, ball_factory)
def make_representation(system, cccp):
"""Using one of the output RMFs as a guide, create the IHM representation
(i.e. the subunits in the system and how residues are represented
as beads)."""
fname = os.path.join('..', 'final_models_1x_Spc29',
'cluster_without_Spc29',
'cluster2.1/top_scoring_model.rmf')
seqs = IMP.pmi.topology.Sequences(
os.path.join('..', '..', 'inputs', 'shared_inputs', 'seqs.fasta'))
ccdatasets = _get_starting_coiled_coil_datasets()
# Mapping from RMF names of subunits to ihm.Entity objects
entities_by_name = {}
# Map from localization density filename to list of asym ranges
density_map = {}
rep = ihm.representation.Representation()
m = IMP.Model()
rh = RMF.open_rmf_file_read_only(fname)
hs = IMP.rmf.create_hierarchies(rh, m)
for h in hs:
name = h.get_name()
entity_name = 'GFP' if name.endswith('GFP') else name
if entity_name not in entities_by_name:
e = ihm.Entity(seqs[entity_name], description=entity_name)
system.entities.append(e)
entities_by_name[entity_name] = e
asym = ihm.AsymUnit(entities_by_name[entity_name], details=name)
system.asym_units.append(asym)
_add_asym_representation(h, asym, rep, ccdatasets, cccp)
_add_density_map(h, asym, density_map)
system.orphan_representations.append(rep)
return entities_by_name, rep, density_map
def _smooth(node, tf, rff, xyz_dict, n=10, is_write=True):
'''
node - node being scanned
tf - typed factory
rff - reference frame factory
# bf - ball factory
xyz_dict - dictinory from node ids to list of up to n xyz coordinates
n - smoothing window size
'''
if tf.get_is(node) and rff.get_is(node):
node_id = node.get_id()
rf = rff.get(node)
xyz = np.array([t for t in rf.get_frame_translation()])
if not node_id in xyz_dict:
xyz_dict[node_id] = [xyz]
else:
xyz_dict[node_id].append(xyz)
if len(xyz_dict[node_id]) > n:
xyz_dict[node_id] = xyz_dict[node_id][-n:]
smooth_xyz = np.mean(xyz_dict[node_id], axis=0)
if is_write:
# print "xyz", xyz
# print "XYZ_LIST", xyz_dict[node_id]
# print "smooth_xyz", smooth_xyz
# print len(smooth_xyz)
rf.set_frame_translation(
RMF.Vector3(smooth_xyz[0], smooth_xyz[1], smooth_xyz[2]))
for c in node.get_children():
_smooth(c, tf, rff, xyz_dict, n)
def test_membrane_pore_restraint(self):
try:
from scipy.spatial import Delaunay
except ImportError:
self.skipTest("no scipy spatial")
m = IMP.Model()
r = IMP.pmi.representation.Representation(m)
smr = IMP.pmi.nonmantained.SetupMembranePoreRestraint(
r,
selection_tuples_outside=None,
selection_tuples_membrane=None,
selection_tuples_inside=None,
center=(0.0, 0.0, 0.0),
z_tickness=100,
radius=300,
membrane_tickness=40.0,
resolution=1,
label="None")
smr.create_representation()
rh = RMF.create_rmf_file("test.rmf3")
IMP.rmf.add_hierarchies(rh, [r.prot])
IMP.rmf.save_frame(rh)
del rh
