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)
Example #3
0
    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()
Example #4
0
    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)
Example #6
0
 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)
Example #8
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)
Example #9
0
    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()
Example #10
0
    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)
Example #11
0
    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()
Example #12
0
    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()
Example #13
0
    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()
Example #14
0
    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)
Example #15
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() )
Example #17
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)
Example #18
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])
        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)
Example #19
0
    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)
Example #20
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])
Example #21
0
    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)
Example #22
0
    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)
Example #24
0
    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)
Example #25
0
    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/")
Example #26
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])
Example #27
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])
        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)
Example #28
0
    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)
Example #29
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)
Example #30
0
 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)
Example #31
0
 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)
Example #32
0
 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)
Example #33
0
 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)
Example #34
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)
Example #35
0
 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)
Example #36
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])
Example #37
0
    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)
Example #38
0
    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)
Example #39
0
    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
Example #41
0
    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)
Example #42
0
    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/")
Example #43
0
    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)
Example #44
0
    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()
Example #45
0
    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()
Example #46
0
    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])
Example #47
0
# 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)
Example #48
0
#  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)
Example #49
0
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]
Example #50
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])
Example #51
0
    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)
Example #52
0
    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')
Example #53
0
# 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)
Example #54
0
    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])
Example #55
0
    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)
Example #56
0
    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
Example #57
0
    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')