def test_molecule_rigid_members2(self): """When the rigid body is created with no assigned nonrigid members all leaves of the molecule are of type RigidMember """ try: import sklearn except ImportError: self.skipTest("no sklearn package") model = IMP.Model() (a1, hier, mol) = self.initialize_system(model) dof = IMP.pmi.dof.DegreesOfFreedom(model) # Create rigid body dof.create_rigid_body(mol) rb = IMP.core.RigidBodyMember( IMP.atom.get_leaves(mol.get_hierarchy())[0]).get_rigid_body() nrms = 0 rms = 0 selection = IMP.atom.Selection( hierarchy=mol.get_hierarchy(), resolution=10).get_hierarchies() all_things = IMP.atom.get_leaves(selection[0]) for part in all_things: if IMP.core.NonRigidMember.get_is_setup(part): nrms += 1 elif IMP.core.RigidMember.get_is_setup(part): rms += 1 else: self.fail("Particle not a RigidMember or a NonRigidMember") self.assertEqual(0, nrms)
def test_molecule_rigid_members(self): """None of the leaves of the molecule are RigidMembers""" try: import sklearn except ImportError: self.skipTest("no sklearn package") model = IMP.Model() (a1, hier, mol) = self.initialize_system(model) dof = IMP.pmi.dof.DegreesOfFreedom(model) dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) rb = IMP.core.RigidBodyMember( IMP.atom.get_leaves(mol.get_hierarchy())[0]).get_rigid_body() nrms = 0 rms = 0 all_things = IMP.atom.get_leaves(mol.get_hierarchy()) for part in all_things: if IMP.core.NonRigidMember.get_is_setup(part): nrms += 1 elif IMP.core.RigidMember.get_is_setup(part): rms += 1 else: self.fail("Particle not a RigidMember or a NonRigidMember") self.assertNotEqual(0, rms)
def test_mc_rigid_body(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() s, molecule = self.init_topology1(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) # Test do-nothing if no rigid parts were passed self.assertEqual(dof.create_rigid_body([], [], name='test RB'), []) rb_movers, rb = dof.create_rigid_body( molecule, nonrigid_parts=molecule.get_non_atomic_residues(), name="test RB") self.assertEqual(rb.get_name(), "test RB") self.assertEqual(rb_movers[0].get_name(), "test RB") mvs = dof.get_movers() self.assertEqual(len(rb_movers), 4) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members) - len(rigid_members) self.assertEqual(num_nonrigid, 3) # r0 r1 r10 self.assertEqual(len(rigid_members), 57 + 7 + 2) rex = IMP.pmi.macros.ReplicaExchange0( mdl, root_hier=s.get_hierarchy(), monte_carlo_sample_objects=dof.get_movers(), number_of_frames=2, test_mode=True, replica_exchange_object=rem) rex.execute_macro()
def test_gaussian_rb(self): mdl = IMP.Model() s, m1, m2, m3 = self.init_topology_densities(mdl) densities = [r.get_hierarchy() for r in m3.get_non_atomic_residues()] gem_xtal = IMP.pmi.restraints.em.GaussianEMRestraint( densities, self.get_input_file_name('prot_gmm.txt'), target_is_rigid_body=True) gem_xtal.get_restraint_set().set_was_used(True) em_rb = gem_xtal.get_rigid_body() em_rb.set_coordinates_are_optimized(False) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) movers, rb = dof.create_rigid_body(em_rb) # Check assigning of names to existing rigid bodies self.assertEqual(movers[0].get_name(), 'created rigid body') movers, rb = dof.create_rigid_body(em_rb, name='foo') self.assertEqual(movers[0].get_name(), 'foo') self.assertTrue(em_rb in dof.get_rigid_bodies()) self.assertEqual(len(dof.get_rigid_bodies()), 2) self.assertTrue(em_rb.get_coordinates_are_optimized()) self.assertEqual(len(dof.get_movers()), 2)
def test_molecule_rigid_members2(self): """When the rigid body is created with no assigned nonrigid members all leaves of the molecule are of type RigidMember """ try: import sklearn except ImportError: self.skipTest("no sklearn package") mdl = IMP.Model() (a1, hier, mol)=self.initialize_system(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) # Create rigid body dof.create_rigid_body(mol) rb = IMP.core.RigidBodyMember(IMP.atom.get_leaves(mol.get_hierarchy())[0]).get_rigid_body() nrms = 0 rms = 0 selection = IMP.atom.Selection(hierarchy=mol.get_hierarchy(),resolution=10).get_hierarchies() all_things = IMP.atom.get_leaves(selection[0]) for part in all_things: if IMP.core.NonRigidMember.get_is_setup(part): nrms += 1 elif IMP.core.RigidMember.get_is_setup(part): rms += 1 else: self.fail("Particle not a RigidMember or a NonRigidMember") self.assertEqual(0,nrms)
def init_representation_complex_pmi2(self, m): pdbfile = self.get_input_file_name("1WCM.pdb") fastafile = self.get_input_file_name("1WCM.fasta.txt") components = ["Rpb1", "Rpb2", "Rpb3", "Rpb4"] chains = "ABCD" beadsize = 20 s = IMP.pmi.topology.System(m) st = s.create_state() seqs = IMP.pmi.topology.Sequences(fastafile) offsets = [0, 0, 0, 0] mols = [] for n in range(len(components)): print('PMI2: setting up', components[n], '1WCM:' + chains[n], offsets[n]) mol = st.create_molecule(components[n], sequence=seqs['1WCM:' + chains[n]], chain_id=chains[n]) atomic = mol.add_structure(pdbfile, chain_id=chains[n], offset=offsets[n], soft_check=True) mol.add_representation(atomic, resolutions=[1, 10, 100]) mol.add_representation(mol[:] - atomic, resolutions=[beadsize]) mols.append(mol) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) for molecule in mols: dof.create_rigid_body( molecule, nonrigid_parts=molecule.get_non_atomic_residues()) return hier, dof
def test_symmetry(self): """Test setup of symmetry""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('chainA.fasta')) st1 = s.create_state() m1 = st1.create_molecule("GCP2_YEAST",sequence=seqs["GCP2_YEAST"][:100],chain_id='A') atomic_res = m1.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1,100)) m1.add_representation(atomic_res,resolutions=[0]) m2 = m1.create_clone('B') m3 = m1.create_clone('C') hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mov1, rb1 = dof.create_rigid_body(m1) mov2, rb2 = dof.create_rigid_body(m2) mov2, rb3 = dof.create_rigid_body(m3) trans = IMP.algebra.Transformation3D([50,0,0]) trans2 = trans*trans IMP.atom.transform(rb2,trans) IMP.atom.transform(rb3,trans2) # setup restraint rs = IMP.pmi.restraints.stereochemistry.SymmetryRestraint(m1,[m2,m3], [trans.get_inverse(), trans2.get_inverse()]) rs.add_to_model() self.assertEqual(float(rs.get_output()['SymmetryRestraint_']),0.0)
def test_molecule_rigid_members1(self): """None of the leaves of the selection (Resolution=10) are RigidMembers""" try: import sklearn except ImportError: self.skipTest("no sklearn package") model = IMP.Model() (a1, hier, mol) = self.initialize_system(model) dof = IMP.pmi.dof.DegreesOfFreedom(model) # Create rigid body dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) rb = IMP.core.RigidBodyMember( IMP.atom.get_leaves(mol.get_hierarchy())[0]).get_rigid_body() nrms = 0 rms = 0 selection = IMP.atom.Selection( hierarchy=mol.get_hierarchy(), resolution=10).get_hierarchies() all_things = IMP.atom.get_leaves(selection[0]) for part in all_things: if IMP.core.NonRigidMember.get_is_setup(part): nrms += 1 elif IMP.core.RigidMember.get_is_setup(part): rms += 1 else: self.fail("Particle not a RigidMember or a NonRigidMember") self.assertNotEqual(0, rms)
def test_mc_rigid_body(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() s,molecule = self.init_topology1(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) # Test do-nothing if no rigid parts were passed self.assertEqual(dof.create_rigid_body([], [], name='test RB'), []) rb_movers,rb = dof.create_rigid_body(molecule, nonrigid_parts = molecule.get_non_atomic_residues(), name="test RB") self.assertEqual(rb.get_name(), "test RB") self.assertEqual(rb_movers[0].get_name(), "test RB") mvs = dof.get_movers() self.assertEqual(len(rb_movers),4) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members)-len(rigid_members) self.assertEqual(num_nonrigid,3) # r0 r1 r10 self.assertEqual(len(rigid_members),57 + 7 + 2) rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=s.get_hierarchy(), monte_carlo_sample_objects = dof.get_movers(), number_of_frames=2, test_mode=True, replica_exchange_object=rem) rex.execute_macro()
def test_symmetry_disables_movers(self): """Test the creation of symmetries""" import math mdl = IMP.Model() s, m1, m2, m3 = self.init_topology_clones(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_movers, rb1 = dof.create_rigid_body( m1, nonrigid_parts=m1.get_non_atomic_residues(), name="test RB 1") rb2_movers, rb2 = dof.create_rigid_body( m2, nonrigid_parts=m2.get_non_atomic_residues(), name="test RB 2") rb3_movers, rb3 = dof.create_rigid_body( m3, nonrigid_parts=m3.get_non_atomic_residues(), name="test RB 3") mvs = dof.get_movers() self.assertEqual(len(mvs), 12) rotational_axis = IMP.algebra.Vector3D(0, 0, 1.0) rotation_angle_12 = 2.0 * math.pi / float(3) * float(1) rotation3D_12 = IMP.algebra.get_rotation_about_axis( rotational_axis, rotation_angle_12) dof.constrain_symmetry([m1], [m2], rotation3D_12, resolution='all') rotation_angle_13 = 2.0 * math.pi / float(3) * float(2) rotation3D_13 = IMP.algebra.get_rotation_about_axis( rotational_axis, rotation_angle_13) dof.constrain_symmetry([m1], [m3], rotation3D_13, resolution='all') mvs = dof.get_movers() mdl.update() self.assertEqual(len(mvs), 4)
def test_rex_multistate(self): """Test you can do multi-state replica exchange""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() m1 = st1.create_molecule("Prot1") atomic_res = m1.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A',res_range=(55,63),offset=-54, soft_check=True) m1.add_representation(m1,resolutions=[1]) st2 = s.create_state() m2 = st2.create_molecule("Prot1") atomic_res2 = m2.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A',res_range=(55,63),offset=-54, soft_check=True) m2.add_representation(m2,resolutions=[1]) hier = s.build() self.assertEqual(len(IMP.atom.get_by_type(hier,IMP.atom.STATE_TYPE)),2) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(m1,nonrigid_parts = atomic_res) dof.create_rigid_body(m2,nonrigid_parts = atomic_res2) rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, monte_carlo_sample_objects=dof.get_movers(), number_of_frames=2, test_mode=True, replica_exchange_object=rem) rex.execute_macro()
def init_topology(self,mdl): s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('seqs.fasta'), name_map={'Protein_1':'Prot1', 'Protein_2':'Prot2', 'Protein_3':'Prot3'}) m1 = st1.create_molecule("Prot1",chain_id='A',sequence=seqs["Prot1"]) m2 = st1.create_molecule("Prot2",chain_id='B',sequence=seqs["Prot2"]) a1 = m1.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A',res_range=(55,64),offset=-54) a2 = m2.add_structure(self.get_input_file_name('prot.pdb'), chain_id='B',res_range=(180,192),offset=-179) m1.add_representation(a1,resolutions=[0,1]) m1.add_representation(m1[:]-a1,resolutions=[1]) m2.add_representation(a2,resolutions=[0,1]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(m1,nonrigid_parts = m1.get_non_atomic_residues(), max_trans=0.1) dof.create_rigid_body(m2,nonrigid_parts = m2.get_non_atomic_residues(), max_trans=0.1) dr = IMP.pmi.restraints.basic.DistanceRestraint(root_hier = hier, tuple_selection1=(1,1,"Prot1",0), tuple_selection2=(1,1,"Prot2",0), distancemin=5, distancemax=15) dr.add_to_model() with IMP.allow_deprecated(): rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, output_objects=[dr], monte_carlo_sample_objects=dof.get_movers(), number_of_frames=10, number_of_best_scoring_models=0, global_output_directory = \ self.get_input_file_name("pmi2_sample_0/")) rex.execute_macro() trans = IMP.algebra.Transformation3D(IMP.algebra.Vector3D(10,10,10)) for rb in dof.rigid_bodies: IMP.core.transform(rb,trans) with IMP.allow_deprecated(): rex2 = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, output_objects=[dr], monte_carlo_sample_objects=dof.get_movers(), number_of_frames=10, number_of_best_scoring_models=0, global_output_directory = \ self.get_input_file_name("pmi2_sample_1/"), replica_exchange_object = rex.get_replica_exchange_object()) rex2.execute_macro()
def init_topology(self,mdl): s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('seqs.fasta'), name_map={'Protein_1':'Prot1', 'Protein_2':'Prot2', 'Protein_3':'Prot3'}) m1 = st1.create_molecule("Prot1",chain_id='A',sequence=seqs["Prot1"]) m2 = st1.create_molecule("Prot2",chain_id='B',sequence=seqs["Prot2"]) a1 = m1.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A',res_range=(55,64),offset=-54) a2 = m2.add_structure(self.get_input_file_name('prot.pdb'), chain_id='B',res_range=(180,192),offset=-179) m1.add_representation(a1,resolutions=[0,1]) m1.add_representation(m1[:]-a1,resolutions=[1]) m2.add_representation(a2,resolutions=[0,1]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(m1,nonrigid_parts = m1.get_non_atomic_residues(), max_trans=0.1) dof.create_rigid_body(m2,nonrigid_parts = m2.get_non_atomic_residues(), max_trans=0.1) dr = IMP.pmi.restraints.basic.DistanceRestraint(root_hier = hier, tuple_selection1=(1,1,"Prot1",0), tuple_selection2=(1,1,"Prot2",0), distancemin=5, distancemax=15) dr.add_to_model() rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, output_objects=[dr], monte_carlo_sample_objects=dof.get_movers(), number_of_frames=10, number_of_best_scoring_models=0, global_output_directory = \ self.get_input_file_name("pmi2_sample_0/")) rex.execute_macro() trans = IMP.algebra.Transformation3D(IMP.algebra.Vector3D(10,10,10)) for rb in dof.rigid_bodies: IMP.core.transform(rb,trans) rex2 = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, output_objects=[dr], monte_carlo_sample_objects=dof.get_movers(), number_of_frames=10, number_of_best_scoring_models=0, global_output_directory = \ self.get_input_file_name("pmi2_sample_1/"), replica_exchange_object = rex.get_replica_exchange_object()) rex2.execute_macro()
def test_shuffle_box(self): """Test shuffling rbs, fbs with bounding box""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences( self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST", sequence=seqs["GCP2_YEAST"][:100], chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1, 100)) mol.add_representation(mol.get_atomic_residues(), resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) mol2 = mol.create_clone('B') mol3 = st1.create_molecule("GCP2_YEAST_BEADS", sequence=seqs["GCP2_YEAST"][:100], chain_id='C') mol3.add_representation(mol3.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mv, rb1 = dof.create_rigid_body( mol, nonrigid_parts=mol.get_non_atomic_residues()) mv, rb2 = dof.create_rigid_body( mol2, nonrigid_parts=mol2.get_non_atomic_residues()) results = IMP.pmi.tools.shuffle_configuration( hier, bounding_box=((1000, 1000, 1000), (1200, 1200, 1200)), return_debug=True) rbs_trans_after = {} fbs_position_after = {} rbs, fbs = IMP.pmi.tools.get_rbs_and_beads([hier]) mdl.update() for rb in rbs: coor_rb = IMP.core.XYZ(rb).get_coordinates() self.assertTrue(1000.0 < coor_rb[0] < 1200.0) self.assertTrue(1000.0 < coor_rb[1] < 1200.0) self.assertTrue(1000.0 < coor_rb[2] < 1200.0) for fb in fbs: coor_fb = IMP.core.XYZ(fb).get_coordinates() self.assertTrue(1000.0 < coor_fb[0] < 1200.0) self.assertTrue(1000.0 < coor_fb[1] < 1200.0) self.assertTrue(1000.0 < coor_fb[2] < 1200.0)
def test_mc_super_rigid_body(self): mdl = IMP.Model() s,mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_mov,rb1 = dof.create_rigid_body(mols[0], nonrigid_parts = mols[0].get_non_atomic_residues()) rb2_mov,rb2 = dof.create_rigid_body(mols[1], nonrigid_parts = mols[1].get_non_atomic_residues()) rb3_mov,rb3 = dof.create_rigid_body(mols[2], nonrigid_parts = mols[2].get_non_atomic_residues()) srb_mover = dof.create_super_rigid_body(mols,chain_min_length=2, chain_max_length=2) ### rbX = dof.create_rigid_body([mols[0],mols[1]]) should fail # rb1:4, rb2:1, rb3:4, srbs:2 mvs = dof.get_movers() self.assertEqual(len(mvs),11)
def test_stereochemistry_basic_rb(self): """ test PMI2 connectivity restraint on basic system with rigid body""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() mol = st1.create_molecule("test", sequence="CHARLES", chain_id="A") mol.add_representation(mol.get_residues(),resolutions=[1]) hier = s.build() # Add rigid body dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rbres = mol[0:4] nrparts = mol[0:1] dof.create_rigid_body(rbres, nonrigid_parts=nrparts) cr1 = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol) self.assertEqual( 4, cr1.get_num_restraints() )
def test_mc_super_rigid_body(self): mdl = IMP.Model() s, mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_mov, rb1 = dof.create_rigid_body( mols[0], nonrigid_parts=mols[0].get_non_atomic_residues()) rb2_mov, rb2 = dof.create_rigid_body( mols[1], nonrigid_parts=mols[1].get_non_atomic_residues()) rb3_mov, rb3 = dof.create_rigid_body( mols[2], nonrigid_parts=mols[2].get_non_atomic_residues()) srb_mover = dof.create_super_rigid_body(mols, chain_min_length=2, chain_max_length=2) ### rbX = dof.create_rigid_body([mols[0],mols[1]]) should fail # rb1:4, rb2:1, rb3:4, srbs:2 mvs = dof.get_movers() self.assertEqual(len(mvs), 11)
def test_shuffle(self): """Test moving rbs, fbs""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST",sequence=seqs["GCP2_YEAST"][:100],chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1,100)) mol.add_representation(mol.get_atomic_residues(),resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) rbs = dof.get_rigid_bodies() IMP.pmi.tools.shuffle_configuration(hier)
def test_shuffle_box(self): """Test shuffling rbs, fbs with bounding box""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST",sequence=seqs["GCP2_YEAST"][:100],chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1,100)) mol.add_representation(mol.get_atomic_residues(),resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) mol2 = mol.create_clone('B') mol3 = st1.create_molecule("GCP2_YEAST_BEADS",sequence=seqs["GCP2_YEAST"][:100],chain_id='C') mol3.add_representation(mol3.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mv,rb1 = dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) mv,rb2 = dof.create_rigid_body(mol2, nonrigid_parts=mol2.get_non_atomic_residues()) results = IMP.pmi.tools.shuffle_configuration(hier, bounding_box=((1000,1000,1000), (1200,1200,1200)),return_debug=True) rbs_trans_after={} fbs_position_after={} rbs,fbs = IMP.pmi.tools.get_rbs_and_beads([hier]) mdl.update() for rb in rbs: coor_rb = IMP.core.XYZ(rb).get_coordinates() self.assertTrue(1000.0 <coor_rb[0]< 1200.0) self.assertTrue(1000.0 <coor_rb[1]< 1200.0) self.assertTrue(1000.0 <coor_rb[2]< 1200.0) for fb in fbs: coor_fb=IMP.core.XYZ(fb).get_coordinates() self.assertTrue(1000.0 <coor_fb[0]< 1200.0) self.assertTrue(1000.0 <coor_fb[1]< 1200.0) self.assertTrue(1000.0 <coor_fb[2]< 1200.0)
def test_shuffle(self): """Test moving rbs, fbs""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences( self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST", sequence=seqs["GCP2_YEAST"][:100], chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1, 100)) mol.add_representation(mol.get_atomic_residues(), resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) mol2 = mol.create_clone('B') hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mv, rb1 = dof.create_rigid_body( mol, nonrigid_parts=mol.get_non_atomic_residues()) mv, rb2 = dof.create_rigid_body( mol2, nonrigid_parts=mol2.get_non_atomic_residues()) results = IMP.pmi.tools.shuffle_configuration(hier, return_debug=True) ps1 = IMP.get_indexes(IMP.core.get_leaves(mol.get_hierarchy())) ps2 = IMP.get_indexes(IMP.core.get_leaves(mol2.get_hierarchy())) self.assertEqual(len(results), 16) self.assertEqual(results[0], [rb1, set(ps2)]) self.assertEqual(results[1], [rb2, set(ps1)]) for r in results[2:]: self.assertFalse(r[1]) # test it works if you pass particles r2 = IMP.pmi.tools.shuffle_configuration(IMP.core.get_leaves(hier), return_debug=True) self.assertEqual(len(r2), 16) self.assertEqual(r2[0], [rb1, set(ps2)]) self.assertEqual(r2[1], [rb2, set(ps1)]) for r in r2[2:]: self.assertFalse(r[1])
def test_gaussian_rb(self): mdl = IMP.Model() m1, m2, m3 = self.init_topology_densities(mdl) densities = [r.get_hierarchy() for r in m3.get_non_atomic_residues()] gem_xtal = IMP.pmi.restraints.em.GaussianEMRestraint(densities, self.get_input_file_name('prot_gmm.txt'), target_is_rigid_body=True) em_rb = gem_xtal.get_rigid_body() em_rb.set_coordinates_are_optimized(False) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(em_rb) self.assertTrue(em_rb in dof.get_rigid_bodies()) self.assertEqual(len(dof.get_rigid_bodies()), 1) self.assertTrue(em_rb.get_coordinates_are_optimized()) self.assertEqual(len(dof.get_movers()), 1)
def test_pdb_multistate(self): """Test PDB writing in PMI2 from replica exchange""" mdl = IMP.Model() pdb_file = self.get_input_file_name("mini.pdb") fasta_file = self.get_input_file_name("mini.fasta") seqs = IMP.pmi.topology.Sequences(fasta_file) s = IMP.pmi.topology.System(mdl) st = s.create_state() molA = st.create_molecule("P1", seqs[0], chain_id='A') aresA = molA.add_structure(pdb_file, chain_id='A', soft_check=True) molA.add_representation(aresA, [0]) st2 = s.create_state() molB = st2.create_molecule("P1", seqs[0], chain_id='A') aresB = molB.add_structure(pdb_file, chain_id='A', soft_check=True) molB.add_representation(molB, [1]) root_hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(molA, name="rbA") dof.create_rigid_body(molB, name="rbB") rex = IMP.pmi.macros.ReplicaExchange0( mdl, root_hier=root_hier, monte_carlo_sample_objects=dof.get_movers(), number_of_frames=3, monte_carlo_steps=10, number_of_best_scoring_models=3, global_output_directory='pdb_test/', replica_exchange_object=rem) rex.execute_macro() for i in range(3): self.assertTrue(os.path.isfile('pdb_test/pdbs/0/model.%i.pdb' % i)) self.assertTrue(os.path.isfile('pdb_test/pdbs/1/model.%i.pdb' % i)) testA = IMP.atom.read_pdb('pdb_test/pdbs/0/model.0.pdb', mdl) self.assertEqual(len(IMP.core.get_leaves(testA)), 53) testB = IMP.atom.read_pdb('pdb_test/pdbs/1/model.0.pdb', mdl) self.assertEqual(len(IMP.core.get_leaves(testB)), 8) shutil.rmtree("pdb_test/")
def test_stereochemistry_system(self): """ test PMI2 connectivity restraint with coarse-grained real system""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST",sequence=seqs["GCP2_YEAST"][:100],chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1,100)) mol.add_representation(mol.get_atomic_residues(),resolutions=[1,10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) cr = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol) self.assertEqual(cr.get_num_restraints(), 8)
def test_gaussian_rb(self): mdl = IMP.Model() m1, m2, m3 = self.init_topology_densities(mdl) densities = [r.get_hierarchy() for r in m3.get_non_atomic_residues()] gem_xtal = IMP.pmi.restraints.em.GaussianEMRestraint( densities, self.get_input_file_name('prot_gmm.txt'), target_is_rigid_body=True) em_rb = gem_xtal.get_rigid_body() em_rb.set_coordinates_are_optimized(False) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(em_rb) self.assertTrue(em_rb in dof.get_rigid_bodies()) self.assertEqual(len(dof.get_rigid_bodies()), 1) self.assertTrue(em_rb.get_coordinates_are_optimized()) self.assertEqual(len(dof.get_movers()), 1)
def test_pdb_multistate(self): """Test PDB writing in PMI2 from replica exchange""" mdl = IMP.Model() pdb_file = self.get_input_file_name("mini.pdb") fasta_file = self.get_input_file_name("mini.fasta") seqs = IMP.pmi.topology.Sequences(fasta_file) s = IMP.pmi.topology.System(mdl) st = s.create_state() molA = st.create_molecule("P1",seqs[0],chain_id='A') aresA = molA.add_structure(pdb_file,chain_id='A',soft_check=True) molA.add_representation(aresA,[0]) st2 = s.create_state() molB = st2.create_molecule("P1",seqs[0],chain_id='A') aresB = molB.add_structure(pdb_file,chain_id='A',soft_check=True) molB.add_representation(molB,[1]) root_hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(molA,name="rbA") dof.create_rigid_body(molB,name="rbB") rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=root_hier, monte_carlo_sample_objects = dof.get_movers(), number_of_frames=3, monte_carlo_steps=10, number_of_best_scoring_models=3, global_output_directory='pdb_test/', replica_exchange_object = rem) rex.execute_macro() for i in range(3): self.assertTrue(os.path.isfile('pdb_test/pdbs/0/model.%i.pdb'%i)) self.assertTrue(os.path.isfile('pdb_test/pdbs/1/model.%i.pdb'%i)) testA = IMP.atom.read_pdb('pdb_test/pdbs/0/model.0.pdb',mdl) self.assertEqual(len(IMP.core.get_leaves(testA)),53) testB = IMP.atom.read_pdb('pdb_test/pdbs/1/model.0.pdb',mdl) self.assertEqual(len(IMP.core.get_leaves(testB)),8) shutil.rmtree("pdb_test/")
def test_constraint_symmetry(self): """Test setup and activity of symmetry constraint""" ### create representation mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('seqs.fasta')) 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_non_atomic_residues(),resolutions=[1]) m3 = m1.create_clone(chain_id='C') m2 = st1.create_molecule("Prot2",sequence=seqs["Protein_2"]) a2 = m2.add_structure(self.get_input_file_name('prot.pdb'), chain_id='B',res_range=(180,192),offset=-179) m2.add_representation(a2,resolutions=[0,1]) m4 = m2.create_clone(chain_id='D') root = s.build() ### create movers and constraints dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_movers = dof.create_rigid_body(m1, nonrigid_parts = m1.get_non_atomic_residues()) rb2_movers = dof.create_rigid_body(m2, nonrigid_parts = m2.get_non_atomic_residues()) dof.create_rigid_body(m3, nonrigid_parts = m3.get_non_atomic_residues()) dof.create_rigid_body(m4, nonrigid_parts = m4.get_non_atomic_residues()) sym_trans = IMP.algebra.get_random_local_transformation(IMP.algebra.Vector3D(0,0,0)) inverse_sym_trans=sym_trans.get_inverse() dof.constrain_symmetry([m1,m2],[m3,m4],sym_trans) m1_leaves = IMP.pmi.tools.select_at_all_resolutions(m1.get_hierarchy()) m3_leaves = IMP.pmi.tools.select_at_all_resolutions(m3.get_hierarchy()) ### test symmetry initially correct mdl.update() for p1,p3 in zip(m1_leaves,m3_leaves): c1 = IMP.core.XYZ(p1).get_coordinates() c3 = inverse_sym_trans*IMP.core.XYZ(p3).get_coordinates() print("AAA",c1,c3) #for i in range(3): # self.assertAlmostEqual(c1[i],c3[i]) ### test transformation propagates rbs,beads = IMP.pmi.tools.get_rbs_and_beads(m1_leaves) test_trans = IMP.algebra.get_random_local_transformation(IMP.algebra.Vector3D(0,0,0)) IMP.core.transform(rbs[0],test_trans) mdl.update() for p1,p3 in zip(m1_leaves,m3_leaves): c1 = IMP.core.XYZ(p1).get_coordinates() c3 = inverse_sym_trans*IMP.core.XYZ(p3).get_coordinates() for i in range(3): self.assertAlmostEqual(c1[i],c3[i])
def test_shuffle(self): """Test moving rbs, fbs""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences( self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST", sequence=seqs["GCP2_YEAST"][:100], chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1, 100)) mol.add_representation(mol.get_atomic_residues(), resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) rbs = dof.get_rigid_bodies() IMP.pmi.tools.shuffle_configuration(hier)
def test_symmetry_disables_movers(self): """Test the creation of symmetries""" import math mdl = IMP.Model() s,m1,m2,m3 = self.init_topology_clones(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_movers,rb1 = dof.create_rigid_body(m1, nonrigid_parts = m1.get_non_atomic_residues(), name="test RB 1") rb2_movers,rb2 = dof.create_rigid_body(m2, nonrigid_parts = m2.get_non_atomic_residues(), name="test RB 2") rb3_movers,rb3 = dof.create_rigid_body(m3, nonrigid_parts = m3.get_non_atomic_residues(), name="test RB 3") mvs = dof.get_movers() self.assertEqual(len(mvs),12) rotational_axis=IMP.algebra.Vector3D(0, 0, 1.0) rotation_angle_12 = 2.0 * math.pi / float(3) * float(1) rotation3D_12 = IMP.algebra.get_rotation_about_axis(rotational_axis, rotation_angle_12) dof.constrain_symmetry( [m1], [m2], rotation3D_12, resolution='all') rotation_angle_13 = 2.0 * math.pi / float(3) * float(2) rotation3D_13 = IMP.algebra.get_rotation_about_axis(rotational_axis, rotation_angle_13) dof.constrain_symmetry( [m1], [m3], rotation3D_13, resolution='all') mvs = dof.get_movers() mdl.update() self.assertEqual(len(mvs),4)
def test_mc_rigid_body(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() molecule = self.init_topology1(mdl) hier = molecule.get_hierarchy() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) sel_nonrigid = IMP.atom.Selection(hier, residue_indexes=[3, 4, 10]) rigid_body = dof.create_rigid_body(hier) rigid_body.create_non_rigid_members(sel_nonrigid) rb = rigid_body.get_rigid_body() mvs = rigid_body.get_movers() self.assertEqual(len(mvs), 4)
def test_slice_rigid_body(self): """test you can create a rigid body from slices of molecules""" mdl = IMP.Model() mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mvs, rb = dof.create_rigid_body([mols[0][:4], mols[1][:]], nonrigid_parts=mols[0][2:4]) self.assertEqual(len(mvs), 3) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members) - len(rigid_members) self.assertEqual(num_nonrigid, 2) # res0 res1 self.assertEqual(len(rigid_members), 18 + 110 + 2 + 13)
def test_slice_rigid_body(self): """test you can create a rigid body from slices of molecules""" mdl = IMP.Model() mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mvs,rb = dof.create_rigid_body([mols[0][:4],mols[1][:]], nonrigid_parts=mols[0][2:4]) self.assertEqual(len(mvs),3) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members)-len(rigid_members) self.assertEqual(num_nonrigid,2) # res0 res1 self.assertEqual(len(rigid_members),18+110 + 2+13)
def test_big_rigid_body(self): """test you can create a rigid body from 3 molecules""" mdl = IMP.Model() s,mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mvs,rb = dof.create_rigid_body(mols, nonrigid_parts=[m.get_non_atomic_residues() for m in mols]) self.assertEqual(len(mvs),1+3+3) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members)-len(rigid_members) self.assertEqual(num_nonrigid,6) # res0 res1 self.assertEqual(len(rigid_members),57+110+57 + 7+13+7)
def test_shuffle_one_rigid_body(self): """Test shuffle of a single rigid body""" m = IMP.Model() s = IMP.pmi.topology.System(m) st1 = s.create_state() nup84 = st1.create_molecule("Nup84", "ME", "X") nup84.add_structure(self.get_input_file_name('test.nup84.pdb'), 'A') nup84.add_representation(resolutions=[1]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) dof.create_rigid_body(nup84) rbs, fbs = IMP.pmi.tools.get_rbs_and_beads(hier) self.assertEqual(len(rbs), 1) self.assertEqual(len(fbs), 0) old_t = rbs[0].get_reference_frame().get_transformation_from() IMP.pmi.tools.shuffle_configuration(hier, bounding_box=((1000, 1000, 1000), (1200, 1200, 1200))) new_t = rbs[0].get_reference_frame().get_transformation_from() # Rigid body should have been translated from near the origin to # somewhere in the bounding box diff_t = old_t.get_translation() - new_t.get_translation() self.assertGreater(diff_t.get_magnitude(), 10.0)
def test_mc_rigid_body(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() molecule = self.init_topology1(mdl) hier = molecule.get_hierarchy() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) sel_nonrigid = IMP.atom.Selection(hier,residue_indexes=[3,4,10]) rigid_body = dof.create_rigid_body(hier) rigid_body.create_non_rigid_members(sel_nonrigid) rb = rigid_body.get_rigid_body() mvs = rigid_body.get_movers() self.assertEqual(len(mvs),4)
def test_big_rigid_body(self): """test you can create a rigid body from 3 molecules""" mdl = IMP.Model() s, mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mvs, rb = dof.create_rigid_body( mols, nonrigid_parts=[m.get_non_atomic_residues() for m in mols]) self.assertEqual(len(mvs), 1 + 3 + 3) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members) - len(rigid_members) self.assertEqual(num_nonrigid, 6) # res0 res1 self.assertEqual(len(rigid_members), 57 + 110 + 57 + 7 + 13 + 7)
def test_shuffle(self): """Test moving rbs, fbs""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST",sequence=seqs["GCP2_YEAST"][:100],chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1,100)) mol.add_representation(mol.get_atomic_residues(),resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) mol2 = mol.create_clone('B') hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mv,rb1 = dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) mv,rb2 = dof.create_rigid_body(mol2, nonrigid_parts=mol2.get_non_atomic_residues()) results = IMP.pmi.tools.shuffle_configuration(hier,return_debug=True) ps1 = IMP.get_indexes(IMP.core.get_leaves(mol.get_hierarchy())) ps2 = IMP.get_indexes(IMP.core.get_leaves(mol2.get_hierarchy())) self.assertEqual(len(results),16) self.assertEqual(results[0],[rb1,set(ps2)]) self.assertEqual(results[1],[rb2,set(ps1)]) for r in results[2:]: self.assertFalse(r[1]) # test it works if you pass particles r2 = IMP.pmi.tools.shuffle_configuration(IMP.core.get_leaves(hier),return_debug=True) self.assertEqual(len(r2),16) self.assertEqual(r2[0],[rb1,set(ps2)]) self.assertEqual(r2[1],[rb2,set(ps1)]) for r in r2[2:]: self.assertFalse(r[1])
def test_gaussian_rb(self): mdl = IMP.Model() s, m1, m2, m3 = self.init_topology_densities(mdl) densities = [r.get_hierarchy() for r in m3.get_non_atomic_residues()] gem_xtal = IMP.pmi.restraints.em.GaussianEMRestraint(densities, self.get_input_file_name('prot_gmm.txt'), target_is_rigid_body=True) gem_xtal.get_restraint_set().set_was_used(True) em_rb = gem_xtal.get_rigid_body() em_rb.set_coordinates_are_optimized(False) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) movers, rb = dof.create_rigid_body(em_rb) # Check assigning of names to existing rigid bodies self.assertEqual(movers[0].get_name(), 'created rigid body') movers, rb = dof.create_rigid_body(em_rb, name='foo') self.assertEqual(movers[0].get_name(), 'foo') self.assertTrue(em_rb in dof.get_rigid_bodies()) self.assertEqual(len(dof.get_rigid_bodies()), 2) self.assertTrue(em_rb.get_coordinates_are_optimized()) self.assertEqual(len(dof.get_movers()), 2)
def test_is_rigid(self): """Test violation of is_rigid flag. This test causes an internal check failure (see issue #853)""" m, r = self.make_representation() chainA = IMP.atom.get_by_type(r, IMP.atom.CHAIN_TYPE)[0] dof = IMP.pmi.dof.DegreesOfFreedom(m) rb1 = dof.create_rigid_body(chainA) ev = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere( included_objects=r, resolution=10.0) ev.add_to_model() sf = IMP.core.RestraintsScoringFunction( IMP.pmi.tools.get_restraint_set(m)) sf.evaluate(False)
def test_rex_multistate(self): """Test you can do multi-state replica exchange""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() m1 = st1.create_molecule("Prot1") atomic_res = m1.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A', res_range=(55, 63), offset=-54, soft_check=True) m1.add_representation(m1, resolutions=[1]) st2 = s.create_state() m2 = st2.create_molecule("Prot1") atomic_res2 = m2.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A', res_range=(55, 63), offset=-54, soft_check=True) m2.add_representation(m2, resolutions=[1]) hier = s.build() self.assertEqual(len(IMP.atom.get_by_type(hier, IMP.atom.STATE_TYPE)), 2) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(m1, nonrigid_parts=atomic_res) dof.create_rigid_body(m2, nonrigid_parts=atomic_res2) rex = IMP.pmi.macros.ReplicaExchange0( mdl, root_hier=hier, monte_carlo_sample_objects=dof.get_movers(), number_of_frames=2, test_mode=True, replica_exchange_object=rem) rex.execute_macro()
def init_representation_complex_pmi2(self,m): pdbfile = self.get_input_file_name("1WCM.pdb") fastafile = self.get_input_file_name("1WCM.fasta.txt") components = ["Rpb1","Rpb2","Rpb3","Rpb4"] chains = "ABCD" beadsize = 20 s = IMP.pmi.topology.System(m) st = s.create_state() seqs = IMP.pmi.topology.Sequences(fastafile) offsets = [0,0,0,0] mols = [] for n in range(len(components)): print('PMI2: setting up',components[n],'1WCM:'+chains[n],offsets[n]) mol = st.create_molecule(components[n],sequence=seqs['1WCM:'+chains[n]],chain_id=chains[n]) atomic = mol.add_structure(pdbfile,chain_id=chains[n],offset=offsets[n],soft_check=True) mol.add_representation(atomic,resolutions=[1,10,100]) mol.add_representation(mol[:]-atomic,resolutions=[beadsize]) mols.append(mol) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) for molecule in mols: dof.create_rigid_body(molecule, nonrigid_parts = molecule.get_non_atomic_residues()) return hier,dof
def test_mc_rigid_body_disable(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() s, molecule = self.init_topology1(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb_movers, rb = dof.create_rigid_body( molecule, nonrigid_parts=molecule.get_non_atomic_residues(), name="test RB") mvs = dof.get_movers() self.assertEqual(len(mvs), 4) #fixing all particles particles = IMP.atom.Selection( s.hier, molecule="Prot1").get_selected_particles() xyzs, rbs = dof.disable_movers(particles) self.assertEqual(len(xyzs), 3) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 0) #enabling everything dof.enable_all_movers() mvs = dof.get_movers() self.assertEqual(len(mvs), 4) #IMP.atom.show_molecular_hierarchy(s.hier) #fixing the rb particles = IMP.atom.Selection( s.hier, molecule="Prot1", residue_indexes=[1]).get_selected_particles() xyzs, rbs = dof.disable_movers(particles) self.assertEqual(len(xyzs), 0) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 3) #fixing one bead and the corresponding rb dof.enable_all_movers() particles = IMP.atom.Selection( s.hier, molecule="Prot1", residue_indexes=[10]).get_selected_particles() xyzs, rbs = dof.disable_movers(particles) self.assertEqual(len(xyzs), 1) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 2)
def test_pdb_from_rex(self): """Test PDB writing in PMI2 from replica exchange""" mdl = IMP.Model() pdb_file = self.get_input_file_name("mini.pdb") fasta_file = self.get_input_file_name("mini.fasta") seqs = IMP.pmi.topology.Sequences(fasta_file) s = IMP.pmi.topology.System(mdl) st = s.create_state() molA = st.create_molecule("P1",seqs[0],chain_id='A') aresA = molA.add_structure(pdb_file,chain_id='A',soft_check=True) molA.add_representation(aresA,[1]) molA.add_representation(molA[:]-aresA,20) molB = st.create_molecule("P2",seqs[1],chain_id='B') aresB = molB.add_structure(pdb_file,chain_id='B',soft_check=True) molB.add_representation(aresB,[10]) molB.add_representation(molB[:]-aresB,20) molC = molB.create_copy(chain_id='C') aresC = molC.add_structure(pdb_file,chain_id='B',soft_check=True) molC.add_representation(aresC,[1,10]) molC.add_representation(molC[:]-aresC,2) root_hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb_movers = dof.create_rigid_body([molA,molB,molC], name="test RB") rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=root_hier, monte_carlo_sample_objects = dof.get_movers(), number_of_frames=3, monte_carlo_steps=10, number_of_best_scoring_models=3, global_output_directory='pdb_test/') rex.execute_macro() for i in range(3): self.assertTrue(os.path.isfile('pdb_test/pdbs/model.%i.pdb'%i)) mhtest = IMP.atom.read_pdb('pdb_test/pdbs/model.0.pdb',mdl) self.assertEqual(len(IMP.core.get_leaves(mhtest)),17) shutil.rmtree("pdb_test/")
def test_mc_rigid_body_disable(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() s,molecule = self.init_topology1(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb_movers,rb = dof.create_rigid_body(molecule, nonrigid_parts = molecule.get_non_atomic_residues(), name="test RB") mvs = dof.get_movers() self.assertEqual(len(mvs),4) #fixing all particles particles=IMP.atom.Selection(s.hier,molecule="Prot1").get_selected_particles() xyzs,rbs=dof.disable_movers(particles) self.assertEqual(len(xyzs),3) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),0) #enabling everything dof.enable_all_movers() mvs = dof.get_movers() self.assertEqual(len(mvs),4) #IMP.atom.show_molecular_hierarchy(s.hier) #fixing the rb particles=IMP.atom.Selection(s.hier,molecule="Prot1",residue_indexes=[1]).get_selected_particles() xyzs,rbs=dof.disable_movers(particles) self.assertEqual(len(xyzs),0) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),3) #fixing one bead and the corresponding rb dof.enable_all_movers() particles=IMP.atom.Selection(s.hier,molecule="Prot1",residue_indexes=[10]).get_selected_particles() xyzs,rbs=dof.disable_movers(particles) self.assertEqual(len(xyzs),1) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),2)
def test_mc_rigid_body_helix(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() s,molecule = self.init_topology_helix(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb_movers,rb = dof.create_rigid_body(molecule, nonrigid_parts = molecule.get_non_atomic_residues(), name="test RB") mvs = dof.get_movers() all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members)-len(rigid_members) rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=s.get_hierarchy(), monte_carlo_sample_objects = dof.get_movers(), number_of_frames=1, test_mode=True, replica_exchange_object=rem) rex.execute_macro()
def test_mc_rigid_body_helix(self): """Test creation of rigid body and nonrigid members""" mdl = IMP.Model() s, molecule = self.init_topology_helix(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb_movers, rb = dof.create_rigid_body( molecule, nonrigid_parts=molecule.get_non_atomic_residues(), name="test RB") mvs = dof.get_movers() all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members) - len(rigid_members) rex = IMP.pmi.macros.ReplicaExchange0( mdl, root_hier=s.get_hierarchy(), monte_carlo_sample_objects=dof.get_movers(), number_of_frames=1, test_mode=True, replica_exchange_object=rem) rex.execute_macro()
def test_shuffle_deep(self): """Test moving rbs, fbs""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences( self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST", sequence=seqs["GCP2_YEAST"][:100], chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1, 100)) mol.add_representation(mol.get_atomic_residues(), resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) mol2 = mol.create_clone('B') mol3 = st1.create_molecule("GCP2_YEAST_BEADS", sequence=seqs["GCP2_YEAST"][:100], chain_id='C') mol3.add_representation(mol3.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) dof.create_rigid_body(mol2, nonrigid_parts=mol2.get_non_atomic_residues()) dof.create_flexible_beads(mol3.get_non_atomic_residues(), max_trans=1.0) rbs, fbs = IMP.pmi.tools.get_rbs_and_beads([hier]) rbs_trans_before = {} fbs_position_before = {} rbs_trans_after = {} fbs_position_after = {} for rb in rbs: rbs_trans_before[rb] = rb.get_reference_frame( ).get_transformation_to() for fb in fbs: if IMP.core.NonRigidMember.get_is_setup(fb): fbs_position_before[fb] = \ IMP.core.NonRigidMember(fb).get_internal_coordinates() else: fbs_position_before[fb] = IMP.core.XYZ(fb).get_coordinates() IMP.pmi.tools.shuffle_configuration(hier) for rb in rbs: rbs_trans_after[rb] = rb.get_reference_frame( ).get_transformation_to() for fb in fbs: if IMP.core.NonRigidMember.get_is_setup(fb): fbs_position_after[fb] = \ IMP.core.NonRigidMember(fb).get_internal_coordinates() else: fbs_position_after[fb] = IMP.core.XYZ(fb).get_coordinates() for fb in fbs: position_after = fbs_position_after[fb] position_before = fbs_position_before[fb] for i in [0, 1, 2]: self.assertNotEqual(position_after[i], position_before[i]) for rb in rbs: position_after = rbs_trans_after[rb].get_translation() position_before = rbs_trans_before[rb].get_translation() rotation_after = rbs_trans_after[rb].get_rotation( ) * IMP.algebra.Vector3D(1, 1, 1) rotation_before = rbs_trans_before[rb].get_rotation( ) * IMP.algebra.Vector3D(1, 1, 1) for i in [0, 1, 2]: self.assertNotEqual(position_after[i], position_before[i]) self.assertNotEqual(rotation_after[i], rotation_before[i])
# Create molecules and add helix representation # this makes a c-alpha chain in approximately the shape of a helix mols = [] for i, len_helix in enumerate([20, 40, 80]): mol = st.create_molecule( "helix_%s" % (str(i)), sequence="A" * len_helix, chain_id="A" ) mol.add_representation(mol, resolutions=[1], ideal_helix=True) mols.append(mol) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(model) for mol in mols: dof.create_rigid_body(mol, max_trans=3.0, max_rot=0.5) ############################## # Connectivity ############################## output_objects = [] sample_objects = [] rmf_restraints = [] crs = [] for mol in mols: cr = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol) cr.set_label(mol.get_name()) cr.add_to_model() output_objects.append(cr) crs.append(cr)
# Once you call build(), anything without representation is destroyed. # You can still use handles like molecule[a:b], molecule.get_atomic_residues() or molecule.get_non_atomic_residues() # However these functions will only return BUILT representations root_hier = s.build() # Uncomment this for verbose output of the representation #IMP.atom.show_with_representations(root_hier) # Setup degrees of freedom # The DOF functions automatically select all resolutions # Objects passed to nonrigid_parts move with the frame but also have their own independent movers. dof = IMP.pmi.dof.DegreesOfFreedom(mdl) for mol in mols: dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues(), max_trans=0.1, max_rot=0.78, nonrigid_max_trans=0.1) ###################### RESTRAINTS ##################### output_objects = [] # keep a list of functions that need to be reported # Connectivity keeps things connected along the backbone (ignores if inside same rigid body) crs = [] for mol in mols: cr = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol) cr.add_to_model() output_objects.append(cr) crs.append(cr)
hier = s.build() # View your creation with this function IMP.atom.show_with_representations(hier) ################ AFTER BUILDING ################### # After building, only what you requested with add_representation() can be selected # PMI selection # Most PMI functions will let you pass Molecules or TempResidues and it will automatically gather things. conn = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol, resolution=1) # Similarly for rigid body creation, we recommend passing PMI objects and it will gather all resolutions dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(mol, nonrigid_parts = non_atomic, resolution='all') # Advanced: IMP selection # Note if you request a resolution this will find the NEAREST available resolution. # E.g. if only resolution 1 is built, those particles will be returned below: sel = IMP.atom.Selection(hier,resolution=10,molecule="Rpb4",residue_indexes=range(1,10)) particles = sel.get_selected_particles() # Retrieving the molecule object # The molecules are stored within the state, so you can do : all_mol_copies = st.molecules["Rpb4"] # a list of all copies mol = all_mol_copies[0]
def test_constraint_symmetry(self): """Test setup and activity of symmetry constraint""" ### create representation mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences( self.get_input_file_name('seqs.fasta')) 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_non_atomic_residues(), resolutions=[1]) m3 = m1.create_clone(chain_id='C') m2 = st1.create_molecule("Prot2", sequence=seqs["Protein_2"]) a2 = m2.add_structure(self.get_input_file_name('prot.pdb'), chain_id='B', res_range=(180, 192), offset=-179) m2.add_representation(a2, resolutions=[0, 1]) m4 = m2.create_clone(chain_id='D') root = s.build() ### create movers and constraints dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_movers = dof.create_rigid_body( m1, nonrigid_parts=m1.get_non_atomic_residues()) rb2_movers = dof.create_rigid_body( m2, nonrigid_parts=m2.get_non_atomic_residues()) dof.create_rigid_body(m3, nonrigid_parts=m3.get_non_atomic_residues()) dof.create_rigid_body(m4, nonrigid_parts=m4.get_non_atomic_residues()) sym_trans = IMP.algebra.get_random_local_transformation( IMP.algebra.Vector3D(0, 0, 0)) inverse_sym_trans = sym_trans.get_inverse() dof.constrain_symmetry([m1, m2], [m3, m4], sym_trans) m1_leaves = IMP.pmi.tools.select_at_all_resolutions(m1.get_hierarchy()) m3_leaves = IMP.pmi.tools.select_at_all_resolutions(m3.get_hierarchy()) ### test symmetry initially correct mdl.update() for p1, p3 in zip(m1_leaves, m3_leaves): c1 = IMP.core.XYZ(p1).get_coordinates() c3 = inverse_sym_trans * IMP.core.XYZ(p3).get_coordinates() print("AAA", c1, c3) #for i in range(3): # self.assertAlmostEqual(c1[i],c3[i]) ### test transformation propagates rbs, beads = IMP.pmi.tools.get_rbs_and_beads(m1_leaves) test_trans = IMP.algebra.get_random_local_transformation( IMP.algebra.Vector3D(0, 0, 0)) IMP.core.transform(rbs[0], test_trans) mdl.update() for p1, p3 in zip(m1_leaves, m3_leaves): c1 = IMP.core.XYZ(p1).get_coordinates() c3 = inverse_sym_trans * IMP.core.XYZ(p3).get_coordinates() for i in range(3): self.assertAlmostEqual(c1[i], c3[i])
def test_mc_super_rigid_body_disable(self): """test disable super rigid bodies, floppy bodies and rigid bodies""" mdl = IMP.Model() s, mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_mov, rb1 = dof.create_rigid_body( mols[0], nonrigid_parts=mols[0].get_non_atomic_residues()) rb2_mov, rb2 = dof.create_rigid_body( mols[1], nonrigid_parts=mols[1].get_non_atomic_residues()) rb3_mov, rb3 = dof.create_rigid_body( mols[2], nonrigid_parts=mols[2].get_non_atomic_residues()) srb_mover = dof.create_super_rigid_body(mols, chain_min_length=2, chain_max_length=2) ### rbX = dof.create_rigid_body([mols[0],mols[1]]) should fail # rb1:4, rb2:1, rb3:4, srbs:2 mvs = dof.get_movers() self.assertEqual(len(mvs), 11) #fixing all particles particles = IMP.atom.Selection(s.hier).get_selected_particles() xyzs, rbs = dof.disable_movers(particles) self.assertEqual(len(xyzs), 6) self.assertEqual(len(rbs), 3) mvs = dof.get_movers() self.assertEqual(len(mvs), 0) #enabling everything dof.enable_all_movers() mvs = dof.get_movers() self.assertEqual(len(mvs), 11) #fixing prot1 particles = IMP.atom.Selection( s.hier, molecule="Prot1").get_selected_particles() xyzs, rbs = dof.disable_movers(particles) self.assertEqual(len(xyzs), 3) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 6) #fixing prot1 rb dof.enable_all_movers() particles = IMP.atom.Selection( s.hier, molecule="Prot1").get_selected_particles() xyzs, rbs = dof.disable_movers(particles, mover_types=[IMP.core.RigidBodyMover]) self.assertEqual(len(xyzs), 0) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 10) #fixing prot1 fbs dof.enable_all_movers() particles = IMP.atom.Selection( s.hier, molecule="Prot1").get_selected_particles() xyzs, rbs = dof.disable_movers(particles, mover_types=[IMP.core.BallMover]) self.assertEqual(len(xyzs), 3) self.assertEqual(len(rbs), 0) mvs = dof.get_movers() self.assertEqual(len(mvs), 8) #removing super rigid body dof.enable_all_movers() particles = IMP.atom.Selection( s.hier, molecule="Prot1").get_selected_particles() xyzs, rbs = dof.disable_movers(particles, mover_types=[IMP.pmi.TransformMover]) self.assertEqual(len(xyzs), 0) self.assertEqual(len(rbs), 0) mvs = dof.get_movers() self.assertEqual(len(mvs), 10) #removing rbmv, ballmovers and super rigid movers involving prot1 dof.enable_all_movers() particles = IMP.atom.Selection( s.hier, molecule="Prot1").get_selected_particles() xyzs, rbs = dof.disable_movers(particles, mover_types=[ IMP.core.RigidBodyMover, IMP.core.BallMover, IMP.pmi.TransformMover ]) self.assertEqual(len(xyzs), 3) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 6) #removing rbmv, ballmovers and super rigid movers involving prot2 dof.enable_all_movers() particles = IMP.atom.Selection( s.hier, molecule="Prot2").get_selected_particles() xyzs, rbs = dof.disable_movers(particles, mover_types=[ IMP.core.RigidBodyMover, IMP.core.BallMover, IMP.pmi.TransformMover ]) self.assertEqual(len(xyzs), 0) self.assertEqual(len(rbs), 1) mvs = dof.get_movers() self.assertEqual(len(mvs), 8)
def test_rigid_body_with_densities(self): """Test still works when you add densities""" try: import sklearn except ImportError: self.skipTest("no sklearn package") mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('seqs.fasta')) 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=[1,10], density_prefix='tmpgmm', density_residues_per_component=5) m1.add_representation(m1.get_non_atomic_residues(), resolutions=[1], setup_particles_as_densities=True) hier = s.build() na = 0 #57 na1 = 7 na10 = 2 naD = 2 nn1 = 3 dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mvs,rb = dof.create_rigid_body(m1, nonrigid_parts = m1.get_non_atomic_residues()) self.assertEqual(len(mvs),4) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members)-len(rigid_members) selD = IMP.atom.Selection(st1.get_hierarchy(),representation_type=IMP.atom.DENSITIES) selA = IMP.atom.Selection(st1.get_hierarchy(),representation_type=IMP.atom.BALLS, resolution=IMP.atom.ALL_RESOLUTIONS) psD = selD.get_selected_particles() psA = selA.get_selected_particles() self.assertEqual(len(rigid_members),na+na1+na10+naD) self.assertEqual(num_nonrigid,nn1) IMP.atom.show_with_representations(hier) itest = IMP.pmi.tools.input_adaptor(m1,pmi_resolution='all',flatten=True) itest2 = IMP.pmi.tools.input_adaptor(m1.get_non_atomic_residues(),pmi_resolution='all',flatten=True) self.assertEqual(len(itest),na+na1+na10+naD+nn1) self.assertEqual(len(itest2),nn1) orig_coords = [IMP.core.XYZ(p).get_coordinates() for p in psD+psA] trans = IMP.algebra.get_random_local_transformation(IMP.algebra.Vector3D(0,0,0)) IMP.core.transform(rb,trans) new_coords = [IMP.core.XYZ(p).get_coordinates() for p in psD+psA] for c1,c2 in zip(orig_coords,new_coords): c1T = trans*c1 print(c1T,c2) self.assertAlmostEqual(IMP.algebra.get_distance(c1T,c2),0.0) os.unlink('tmpgmm.mrc') os.unlink('tmpgmm.txt')
# Create molecules and add helix representation # this makes a c-alpha chain in approximately the shape of a helix mols = [] for i, len_helix in enumerate([20, 40, 80]): mol = st.create_molecule("helix_%s" % (str(i)), sequence="A" * len_helix, chain_id="A") mol.add_representation(mol, resolutions=[1], ideal_helix=True) mols.append(mol) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(model) for mol in mols: dof.create_rigid_body(mol, max_trans=3.0, max_rot=0.5) ############################## # Connectivity ############################## output_objects = [] sample_objects = [] rmf_restraints = [] crs = [] for mol in mols: cr = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol) cr.set_label(mol.get_name()) cr.add_to_model() output_objects.append(cr) crs.append(cr)
def test_shuffle_deep(self): """Test moving rbs, fbs""" mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('chainA.fasta')) st1 = s.create_state() mol = st1.create_molecule("GCP2_YEAST",sequence=seqs["GCP2_YEAST"][:100],chain_id='A') atomic_res = mol.add_structure(self.get_input_file_name('chainA.pdb'), chain_id='A', res_range=(1,100)) mol.add_representation(mol.get_atomic_residues(),resolutions=[10]) mol.add_representation(mol.get_non_atomic_residues(), resolutions=[10]) mol2 = mol.create_clone('B') mol3 = st1.create_molecule("GCP2_YEAST_BEADS",sequence=seqs["GCP2_YEAST"][:100],chain_id='C') mol3.add_representation(mol3.get_non_atomic_residues(), resolutions=[10]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) dof.create_rigid_body(mol, nonrigid_parts=mol.get_non_atomic_residues()) dof.create_rigid_body(mol2, nonrigid_parts=mol2.get_non_atomic_residues()) dof.create_flexible_beads(mol3.get_non_atomic_residues(),max_trans=1.0) rbs,fbs = IMP.pmi.tools.get_rbs_and_beads([hier]) rbs_trans_before={} fbs_position_before={} rbs_trans_after={} fbs_position_after={} for rb in rbs: rbs_trans_before[rb]=rb.get_reference_frame().get_transformation_to() for fb in fbs: if IMP.core.NonRigidMember.get_is_setup(fb): fbs_position_before[fb] = \ IMP.core.NonRigidMember(fb).get_internal_coordinates() else: fbs_position_before[fb]=IMP.core.XYZ(fb).get_coordinates() IMP.pmi.tools.shuffle_configuration(hier) for rb in rbs: rbs_trans_after[rb]=rb.get_reference_frame().get_transformation_to() for fb in fbs: if IMP.core.NonRigidMember.get_is_setup(fb): fbs_position_after[fb] = \ IMP.core.NonRigidMember(fb).get_internal_coordinates() else: fbs_position_after[fb]=IMP.core.XYZ(fb).get_coordinates() for fb in fbs: position_after=fbs_position_after[fb] position_before=fbs_position_before[fb] for i in [0,1,2]: self.assertNotEqual(position_after[i],position_before[i]) for rb in rbs: position_after=rbs_trans_after[rb].get_translation() position_before=rbs_trans_before[rb].get_translation() rotation_after=rbs_trans_after[rb].get_rotation()*IMP.algebra.Vector3D(1,1,1) rotation_before=rbs_trans_before[rb].get_rotation()*IMP.algebra.Vector3D(1,1,1) for i in [0,1,2]: self.assertNotEqual(position_after[i],position_before[i]) self.assertNotEqual(rotation_after[i],rotation_before[i])
def test_mc_super_rigid_body_disable(self): """test disable super rigid bodies, floppy bodies and rigid bodies""" mdl = IMP.Model() s,mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) rb1_mov,rb1 = dof.create_rigid_body(mols[0], nonrigid_parts = mols[0].get_non_atomic_residues()) rb2_mov,rb2 = dof.create_rigid_body(mols[1], nonrigid_parts = mols[1].get_non_atomic_residues()) rb3_mov,rb3 = dof.create_rigid_body(mols[2], nonrigid_parts = mols[2].get_non_atomic_residues()) srb_mover = dof.create_super_rigid_body(mols,chain_min_length=2, chain_max_length=2) ### rbX = dof.create_rigid_body([mols[0],mols[1]]) should fail # rb1:4, rb2:1, rb3:4, srbs:2 mvs = dof.get_movers() self.assertEqual(len(mvs),11) #fixing all particles particles=IMP.atom.Selection(s.hier).get_selected_particles() xyzs,rbs=dof.disable_movers(particles) self.assertEqual(len(xyzs),6) self.assertEqual(len(rbs),3) mvs = dof.get_movers() self.assertEqual(len(mvs),0) #enabling everything dof.enable_all_movers() mvs = dof.get_movers() self.assertEqual(len(mvs),11) #fixing prot1 particles=IMP.atom.Selection(s.hier,molecule="Prot1").get_selected_particles() xyzs,rbs=dof.disable_movers(particles) self.assertEqual(len(xyzs),3) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),6) #fixing prot1 rb dof.enable_all_movers() particles=IMP.atom.Selection(s.hier,molecule="Prot1").get_selected_particles() xyzs,rbs=dof.disable_movers(particles,mover_types=[IMP.core.RigidBodyMover]) self.assertEqual(len(xyzs),0) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),10) #fixing prot1 fbs dof.enable_all_movers() particles=IMP.atom.Selection(s.hier,molecule="Prot1").get_selected_particles() xyzs,rbs=dof.disable_movers(particles,mover_types=[IMP.core.BallMover]) self.assertEqual(len(xyzs),3) self.assertEqual(len(rbs),0) mvs = dof.get_movers() self.assertEqual(len(mvs),8) #removing super rigid body dof.enable_all_movers() particles=IMP.atom.Selection(s.hier,molecule="Prot1").get_selected_particles() xyzs,rbs=dof.disable_movers(particles,mover_types=[IMP.pmi.TransformMover]) self.assertEqual(len(xyzs),0) self.assertEqual(len(rbs),0) mvs = dof.get_movers() self.assertEqual(len(mvs),10) #removing rbmv, ballmovers and super rigid movers involving prot1 dof.enable_all_movers() particles=IMP.atom.Selection(s.hier,molecule="Prot1").get_selected_particles() xyzs,rbs=dof.disable_movers(particles,mover_types=[IMP.core.RigidBodyMover,IMP.core.BallMover,IMP.pmi.TransformMover]) self.assertEqual(len(xyzs),3) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),6) #removing rbmv, ballmovers and super rigid movers involving prot2 dof.enable_all_movers() particles=IMP.atom.Selection(s.hier,molecule="Prot2").get_selected_particles() xyzs,rbs=dof.disable_movers(particles,mover_types=[IMP.core.RigidBodyMover,IMP.core.BallMover,IMP.pmi.TransformMover]) self.assertEqual(len(xyzs),0) self.assertEqual(len(rbs),1) mvs = dof.get_movers() self.assertEqual(len(mvs),8)
def init_with_copies(self,mdl): s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('seqs.fasta'), name_map={'Protein_1':'Prot1', 'Protein_2':'Prot2', 'Protein_3':'Prot3'}) m1 = st1.create_molecule("Prot1",chain_id='A',sequence=seqs["Prot1"]) a1 = m1.add_structure(self.get_input_file_name('prot.pdb'), chain_id='A',res_range=(55,64),offset=-54) m1.add_representation(a1,resolutions=[1]) m1.add_representation(m1[:]-a1,resolutions=[1]) m2 = m1.create_clone('B') hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mv1,rb1 = dof.create_rigid_body(m1,nonrigid_parts = m1.get_non_atomic_residues(), max_trans=0.000001) mv2,rb2 = dof.create_rigid_body(m2,nonrigid_parts = m2.get_non_atomic_residues(), max_trans=0.000001) trans = IMP.algebra.Transformation3D(IMP.algebra.Vector3D(100,0,0)) IMP.core.transform(rb2,trans) ps0 = IMP.atom.Selection(hier,molecule='Prot1',copy_index=0).get_selected_particles() ps1 = IMP.atom.Selection(hier,molecule='Prot1',copy_index=1).get_selected_particles() with IMP.allow_deprecated(): rex = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, monte_carlo_sample_objects=dof.get_movers(), number_of_frames=1, number_of_best_scoring_models=0, global_output_directory = \ self.get_input_file_name("pmi2_copies_0/")) rex.execute_macro() coords0A = [IMP.core.XYZ(p).get_coordinates() for p in ps0] coords1A = [IMP.core.XYZ(p).get_coordinates() for p in ps1] # swap the objects IMP.core.transform(rb2,trans.get_inverse()) IMP.core.transform(rb1,trans) with IMP.allow_deprecated(): rex2 = IMP.pmi.macros.ReplicaExchange0(mdl, root_hier=hier, monte_carlo_sample_objects=dof.get_movers(), number_of_frames=1, number_of_best_scoring_models=0, global_output_directory = \ self.get_input_file_name("pmi2_copies_1/"), replica_exchange_object = rex.get_replica_exchange_object()) rex2.execute_macro() coords0B = [IMP.core.XYZ(p).get_coordinates() for p in ps0] coords1B = [IMP.core.XYZ(p).get_coordinates() for p in ps1] rmsd = IMP.algebra.get_rmsd(coords0A+coords1A,coords1B+coords0B) return rmsd
def test_rigid_body_with_densities(self): """Test still works when you add densities""" try: import sklearn except ImportError: self.skipTest("no sklearn package") mdl = IMP.Model() s = IMP.pmi.topology.System(mdl) st1 = s.create_state() seqs = IMP.pmi.topology.Sequences( self.get_input_file_name('seqs.fasta')) 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=[1, 10], density_prefix='tmpgmm', density_residues_per_component=5) m1.add_representation(m1.get_non_atomic_residues(), resolutions=[1], setup_particles_as_densities=True) hier = s.build() na = 0 #57 na1 = 7 na10 = 2 naD = 2 nn1 = 3 dof = IMP.pmi.dof.DegreesOfFreedom(mdl) mvs, rb = dof.create_rigid_body( m1, nonrigid_parts=m1.get_non_atomic_residues()) self.assertEqual(len(mvs), 4) all_members = rb.get_member_indexes() rigid_members = rb.get_rigid_members() num_nonrigid = len(all_members) - len(rigid_members) selD = IMP.atom.Selection(st1.get_hierarchy(), representation_type=IMP.atom.DENSITIES) selA = IMP.atom.Selection(st1.get_hierarchy(), representation_type=IMP.atom.BALLS, resolution=IMP.atom.ALL_RESOLUTIONS) psD = selD.get_selected_particles() psA = selA.get_selected_particles() self.assertEqual(len(rigid_members), na + na1 + na10 + naD) self.assertEqual(num_nonrigid, nn1) IMP.atom.show_with_representations(hier) itest = IMP.pmi.tools.input_adaptor(m1, pmi_resolution='all', flatten=True) itest2 = IMP.pmi.tools.input_adaptor(m1.get_non_atomic_residues(), pmi_resolution='all', flatten=True) self.assertEqual(len(itest), na + na1 + na10 + naD + nn1) self.assertEqual(len(itest2), nn1) orig_coords = [IMP.core.XYZ(p).get_coordinates() for p in psD + psA] trans = IMP.algebra.get_random_local_transformation( IMP.algebra.Vector3D(0, 0, 0)) IMP.core.transform(rb, trans) new_coords = [IMP.core.XYZ(p).get_coordinates() for p in psD + psA] for c1, c2 in zip(orig_coords, new_coords): c1T = trans * c1 print(c1T, c2) self.assertAlmostEqual(IMP.algebra.get_distance(c1T, c2), 0.0) os.unlink('tmpgmm.mrc') os.unlink('tmpgmm.txt')