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