Exemple #1
0
    def test_mc_flexible_beads_disable(self):
        """Test disable of flexible beads"""
        mdl = IMP.Model()
        s,mol = self.init_topology1(mdl)
        dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
        fb_movers = dof.create_flexible_beads(mol.get_non_atomic_residues(),max_trans=1.0)
        self.assertEqual(len(fb_movers),3)
        mvs = dof.get_movers()
        self.assertEqual(len(mvs),3)

        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),0)
        mvs = dof.get_movers()
        self.assertEqual(len(mvs),0)

        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),0)
        mvs = dof.get_movers()
        self.assertEqual(len(mvs),3)

        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),0)
Exemple #2
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)
Exemple #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()
Exemple #4
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()
Exemple #5
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()
Exemple #6
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()
Exemple #7
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()
Exemple #8
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)
Exemple #9
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)
Exemple #10
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)
Exemple #11
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()
Exemple #12
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)
Exemple #13
0
    def test_mc_flexible_beads_disable(self):
        """Test disable of flexible beads"""
        mdl = IMP.Model()
        s, mol = self.init_topology1(mdl)
        dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
        fb_movers = dof.create_flexible_beads(mol.get_non_atomic_residues(),
                                              max_trans=1.0)
        self.assertEqual(len(fb_movers), 3)
        mvs = dof.get_movers()
        self.assertEqual(len(mvs), 3)

        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), 0)
        mvs = dof.get_movers()
        self.assertEqual(len(mvs), 0)

        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), 0)
        mvs = dof.get_movers()
        self.assertEqual(len(mvs), 3)

        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), 0)
Exemple #14
0
 def test_mc_flexible_beads(self):
     """Test setup of flexible beads"""
     mdl = IMP.Model()
     s,mol = self.init_topology1(mdl)
     dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
     fb_movers = dof.create_flexible_beads(mol.get_non_atomic_residues(),max_trans=1.0)
     self.assertEqual(len(fb_movers),3)
     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()
Exemple #15
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()
Exemple #16
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)
Exemple #17
0
 def test_mc_flexible_beads(self):
     """Test setup of flexible beads"""
     mdl = IMP.Model()
     s, mol = self.init_topology1(mdl)
     dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
     fb_movers = dof.create_flexible_beads(mol.get_non_atomic_residues(),
                                           max_trans=1.0)
     self.assertEqual(len(fb_movers), 3)
     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()
Exemple #18
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)
Exemple #19
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/',
                                              replica_exchange_object = rem)
        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/")
Exemple #20
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)
Exemple #21
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/',
            replica_exchange_object=rem)
        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/")
Exemple #22
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)
Exemple #23
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()
Exemple #24
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)
Exemple #25
0
#psi = xlr.psi_dictionary["PSI"][0]
#psi.set_scale(0.04)
sf = IMP.core.RestraintsScoringFunction(IMP.pmi.tools.get_restraint_set(mdl))
print(sf.evaluate(False))

dof.get_nuisances_from_restraint(
    xlr)  # needed to sample the nuisance particles (noise params)

####################### SAMPLING #####################
# First shuffle the system

if not s.dry_run:
    IMP.pmi.tools.shuffle_configuration(gdown1)

    dof.optimize_flexible_beads(100)
print(dof.get_movers())
print(len(dof.get_movers()))
print(gdown1)
# Run replica exchange Monte Carlo sampling
rex = IMP.pmi.macros.ReplicaExchange0(
    mdl,
    root_hier=root_hier,  # pass the root hierarchy
    crosslink_restraints=display_restraints,  # will display like XLs
    monte_carlo_temperature=1.0,
    replica_exchange_minimum_temperature=1.0,
    replica_exchange_maximum_temperature=2.5,
    num_sample_rounds=1,
    number_of_best_scoring_models=5,
    monte_carlo_sample_objects=dof.get_movers(),  # pass MC movers
    global_output_directory='gdownrb_%d' % taskid,
    output_objects=output_objects,
Exemple #26
0
    log_objects.append(rbr)

    rar = IMP.pmi.restraints.stereochemistry.ResidueAngleRestraint(objects=l)
    rar.add_to_model()
    listofexcludedpairs += rar.get_excluded_pairs()
    log_objects.append(rar)

# add excluded volume

ev = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(
    included_objects=root_hier, resolution=10.0)
ev.add_excluded_particle_pairs(listofexcludedpairs)
ev.add_to_model()
log_objects.append(ev)

mc = samplers.MonteCarlo(m, dof.get_movers(), 1.0)
log_objects.append(mc)

start_time = process_time()
# In debug mode things are way too slow to actually run MC
if IMP.get_check_level() < IMP.USAGE_AND_INTERNAL:
    o = output.Output()
    rmf = o.init_rmf("conformations.rmf3", [root_hier])
    o.init_stat2("modeling.stat", log_objects)
    o.write_rmf("conformations.rmf3")
    o.init_pdb("conformations.pdb", root_hier)

    for i in range(0, 10):
        #       print("Running job, frame number ", i)

        mc.optimize(10)
Exemple #27
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)
Exemple #28
0
    def test_macro_rmf_stat(self):
        """setting up the representation
        PMI 2.0 representation. Creates two particles and
        a harmonic distance restraint between them"""
        import shutil
        import itertools
        m = IMP.Model()
        s = IMP.pmi.topology.System(m)
        st1 = s.create_state()
        mol = st1.create_molecule("A", "GG", "A")
        mol.add_representation(resolutions=[1])
        hier = s.build()

        dof = IMP.pmi.dof.DegreesOfFreedom(mol)
        dof.create_flexible_beads(mol, max_trans=3.0, resolution=1)

        ps = IMP.atom.get_leaves(hier)
        dr = IMP.pmi.restraints.basic.DistanceRestraint(root_hier=hier,
                                                        tuple_selection1=(1, 1,
                                                                          "A"),
                                                        tuple_selection2=(2, 2,
                                                                          "A"),
                                                        distancemin=10,
                                                        distancemax=10)

        dr.add_to_model()
        rex = IMP.pmi.macros.ReplicaExchange0(
            m,
            root_hier=hier,
            monte_carlo_sample_objects=dof.get_movers(),
            output_objects=None,
            rmf_output_objects=[dr],
            monte_carlo_temperature=1.0,
            replica_exchange_minimum_temperature=1.0,
            replica_exchange_maximum_temperature=2.5,
            number_of_best_scoring_models=10,
            monte_carlo_steps=10,
            number_of_frames=100,
            write_initial_rmf=True,
            initial_rmf_name_suffix="initial",
            stat_file_name_suffix="stat",
            best_pdb_name_suffix="model",
            do_clean_first=True,
            do_create_directories=True,
            global_output_directory="./test_replica_exchange_macro_output",
            rmf_dir="rmfs/",
            best_pdb_dir="pdbs/",
            replica_stat_file_suffix="stat_replica",
            em_object_for_rmf=None,
            replica_exchange_object=None)

        # check whether the directory is existing, in case remove it
        try:
            shutil.rmtree('./test_replica_exchange_macro_output')
        except OSError:
            pass

        rex.execute_macro()

        self.check_rmf_file('./test_replica_exchange_macro_output/rmfs/0.rmf3')

        # check that each replica index is below the total number of replicas
        my_index = rex.replica_exchange_object.get_my_index()
        nreplicas = rex.replica_exchange_object.get_number_of_replicas()
        temperatures = rex.replica_exchange_object.get_my_parameter("temp")
        self.assertLess(my_index, nreplicas)

        # check that each replica has a unique index
        tf = open(
            "./test_replica_exchange_macro_output/" + str(my_index) + ".test",
            "w")
        tf.write(str(my_index))
        tf.close()
        # sleep to synchronize
        time.sleep(1)
        if my_index == 0:
            for k in range(nreplicas):
                self.assertTrue(
                    os.path.isfile("./test_replica_exchange_macro_output/" +
                                   str(k) + ".test"))

        #extract the info form the stat files
        rex_out_files = glob.glob(
            "./test_replica_exchange_macro_output/stat_replica.*.out")
        temp_key = "ReplicaExchange_CurrentTemp"
        maxtf_key = "ReplicaExchange_MaxTempFrequency"
        mintf_key = "ReplicaExchange_MinTempFrequency"
        ssr_key = "ReplicaExchange_SwapSuccessRatio"
        score_key = "score"
        score_temp_dict = {}
        avtemps_replicas = []
        for f in rex_out_files:
            o = IMP.pmi.output.ProcessOutput(f)
            d = o.get_fields(
                [temp_key, maxtf_key, mintf_key, ssr_key, score_key])
            temps = [float(f) for f in d[temp_key]]
            scores = [float(f) for f in d[score_key]]
            avtemp = sum(temps) / len(temps)
            avtemps_replicas.append(avtemp)
            for n, t in enumerate(temps):
                s = scores[n]
                if t not in score_temp_dict:
                    score_temp_dict[t] = [s]
                else:
                    score_temp_dict[t].append(s)
        # test that the average temperature per replica are similar
        for c in itertools.combinations(avtemps_replicas, 2):
            self.assertAlmostEqual(c[0], c[1], delta=0.05)
        for t in score_temp_dict:
            avscore = sum(score_temp_dict[t]) / len(score_temp_dict[t])
            #check that the score is the energy of an 1D harmonic oscillator
            self.assertAlmostEqual(avscore, t / 2, delta=0.1)

        rex_out_file = "./test_replica_exchange_macro_output/rmfs/" + str(
            my_index) + ".rmf3"
        dist_key = "DistanceRestraint_Score"
        mc_nframe_key = "MonteCarlo_Nframe"
        mc_temp_key = "MonteCarlo_Temperature"
        rex_temp_key = "ReplicaExchange_CurrentTemp"
        rex_max_temp_key = "ReplicaExchange_MaxTempFrequency"
        rex_min_temp_key = "ReplicaExchange_MinTempFrequency"
        rex_swap_key = "ReplicaExchange_SwapSuccessRatio"
        rex_score_key = "Total_Score"
        rmf_file_key = "rmf_file"
        rmf_file_index = "rmf_frame_index"
        o = IMP.pmi.output.ProcessOutput(rex_out_file)
        d = o.get_fields([
            dist_key, mc_temp_key, mc_nframe_key, rex_temp_key,
            rex_max_temp_key, rex_min_temp_key, rex_swap_key, rex_score_key,
            rmf_file_key, rmf_file_index
        ])
        nframes = len(d[mc_nframe_key])
        self.assertNotEqual(float(d[mc_nframe_key][-1]), 0)
        self.assertEqual(list(map(float, d[mc_temp_key])), [1.0] * nframes)
        self.assertGreater(float(d[rex_min_temp_key][-1]), 0.0)
Exemple #29
0
    def test_atomic_xl(self):
        """ test PMI setup of atomic XL restraint """

        # fake data
        tname = self.get_tmp_file_name("test.txt")
        with open(tname, "w") as fh:
            fh.write("prot1,res1,prot2,res2\nProt1,7,Prot1,39\n")

        cldbkc = IMP.pmi.io.crosslink.CrossLinkDataBaseKeywordsConverter()
        cldbkc.set_protein1_key("prot1")
        cldbkc.set_protein2_key("prot2")
        cldbkc.set_residue1_key("res1")
        cldbkc.set_residue2_key("res2")
        cldb = IMP.pmi.io.crosslink.CrossLinkDataBase(cldbkc)
        cldb.create_set_from_file(tname)

        self.assertEqual(cldb.get_number_of_xlid(), 1)

        # create two states, each with two copies of the protein
        mdl = IMP.Model()
        s = IMP.pmi.topology.System(mdl)
        seqs = IMP.pmi.topology.Sequences(
            self.get_input_file_name('multi_seq.fasta'),
            name_map={'Protein_1': 'Prot1'})
        # build state 1
        st1 = s.create_state()
        m1 = st1.create_molecule("Prot1", sequence=seqs["Prot1"], chain_id='A')
        m1_res = m1.add_structure(self.get_input_file_name('multi.pdb'),
                                  chain_id='A',
                                  offset=-54,
                                  model_num=0)
        m1.add_representation(m1_res, resolutions=[0])

        m1a = m1.create_copy(chain_id='G')
        m1a_res = m1a.add_structure(self.get_input_file_name('multi.pdb'),
                                    chain_id='G',
                                    offset=-54)
        m1a.add_representation(m1a_res, resolutions=[0])

        # build state 2
        st2 = s.create_state()
        m2 = st2.create_molecule("Prot1", sequence=seqs["Prot1"], chain_id='A')
        m2_res = m2.add_structure(self.get_input_file_name('multi.pdb'),
                                  chain_id='A',
                                  offset=-54,
                                  model_num=1)
        m2.add_representation(m2_res, resolutions=[0])

        m2a = m2.create_copy(chain_id='G')
        m2a_res = m2a.add_structure(self.get_input_file_name('multi.pdb'),
                                    chain_id='G',
                                    offset=-54)
        m2a.add_representation(m2a_res, resolutions=[0])

        hier = s.build()

        #IMP.atom.show_molecular_hierarchy(hier)
        xl = IMP.pmi.restraints.crosslinking.AtomicCrossLinkMSRestraint(
            hier, cldb, nstates=[0, 1], atom_type="CA")

        # check that you created 8 restraints:
        #  Each state: A1-B1, A1-B2, A2-B1, A2-B2
        rs = xl.get_restraint_set()
        rs.set_was_used(True)
        self.assertEqual(rs.get_number_of_restraints(), 1)
        xlrs = IMP.isd.AtomicCrossLinkMSRestraint.get_from(rs.get_restraint(0))
        self.assertIsInstance(xlrs, IMP.isd.AtomicCrossLinkMSRestraint)
        self.assertEqual(xlrs.get_number_of_contributions(), 8)

        dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
        dof.get_nuisances_from_restraint(xl)
        self.assertEqual(len(dof.get_movers()), 2)
    def test_atomic_xl(self):
        """ test PMI setup of atomic XL restraint """

        # fake data
        tname = self.get_tmp_file_name("test.txt")
        with open(tname, "w") as fh:
            fh.write("prot1,res1,prot2,res2\nProt1,7,Prot1,39\n")

        cldbkc=IMP.pmi.io.crosslink.CrossLinkDataBaseKeywordsConverter()
        cldbkc.set_protein1_key("prot1")
        cldbkc.set_protein2_key("prot2")
        cldbkc.set_residue1_key("res1")
        cldbkc.set_residue2_key("res2")
        cldb = IMP.pmi.io.crosslink.CrossLinkDataBase(cldbkc)
        cldb.create_set_from_file(tname)

        self.assertEqual(cldb.get_number_of_xlid(),1)

        # create two states, each with two copies of the protein
        mdl = IMP.Model()
        s = IMP.pmi.topology.System(mdl)
        seqs = IMP.pmi.topology.Sequences(self.get_input_file_name('multi_seq.fasta'),
                         name_map={'Protein_1':'Prot1'})
        # build state 1
        st1 = s.create_state()
        m1 = st1.create_molecule("Prot1",sequence=seqs["Prot1"],chain_id='A')
        m1_res = m1.add_structure(self.get_input_file_name('multi.pdb'),
                                  chain_id='A',offset=-54,
                                  model_num=0)
        m1.add_representation(m1_res,resolutions=[0])

        m1a = m1.create_copy(chain_id='G')
        m1a_res = m1a.add_structure(self.get_input_file_name('multi.pdb'),chain_id='G',offset=-54)
        m1a.add_representation(m1a_res,resolutions=[0])

        # build state 2
        st2 = s.create_state()
        m2 = st2.create_molecule("Prot1",sequence=seqs["Prot1"],chain_id='A')
        m2_res = m2.add_structure(self.get_input_file_name('multi.pdb'),
                                  chain_id='A',offset=-54,
                                  model_num=1)
        m2.add_representation(m2_res,resolutions=[0])

        m2a = m2.create_copy(chain_id='G')
        m2a_res = m2a.add_structure(self.get_input_file_name('multi.pdb'),chain_id='G',offset=-54)
        m2a.add_representation(m2a_res,resolutions=[0])

        hier = s.build()

        #IMP.atom.show_molecular_hierarchy(hier)
        xl = IMP.pmi.restraints.crosslinking.AtomicCrossLinkMSRestraint(hier,
                                                                        cldb,
                                                                        nstates=[0,1],
                                                                        atom_type="CA")

        # check that you created 8 restraints:
        #  Each state: A1-B1, A1-B2, A2-B1, A2-B2
        rs=xl.get_restraint_set()
        self.assertEqual(rs.get_number_of_restraints(),1)
        xlrs=IMP.isd.AtomicCrossLinkMSRestraint.get_from(rs.get_restraint(0))
        self.assertIsInstance(xlrs,IMP.isd.AtomicCrossLinkMSRestraint)
        self.assertEqual(xlrs.get_number_of_contributions(),8)

        dof = IMP.pmi.dof.DegreesOfFreedom(mdl)
        dof.get_nuisances_from_restraint(xl)
        self.assertEqual(len(dof.get_movers()),2)
Exemple #31
0
psi.set_scale(0.05)
xl.set_psi_is_sampled(True)
xl.set_sigma_is_sampled(True)
sample_objects.append(xl)
output_objects.append(xl)

###################### SAMPLING #####################
# First shuffle the system
IMP.pmi.tools.shuffle_configuration(hier, max_translation=100)

# Quickly move all flexible beads into place
dof.optimize_flexible_beads(10)

# Run replica exchange Monte Carlo sampling
rex = IMP.pmi.macros.ReplicaExchange0(
    mdl,
    root_hier=hier,  # pass the root hierarchy
    crosslink_restraints=[xl],  # will display like XLs
    monte_carlo_sample_objects=dof.get_movers() +
    xl.get_movers(),  # pass MC movers
    global_output_directory='output/',
    output_objects=output_objects,
    monte_carlo_temperature=1.0,
    replica_exchange_minimum_temperature=1.0,
    replica_exchange_maximum_temperature=2.5,
    monte_carlo_steps=10,
    number_of_best_scoring_models=
    0,  # set >0 to store best PDB files (but this is slow to do online)
    number_of_frames=10000)  # increase number of frames to get better results!
rex.execute_macro()
Exemple #32
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)
    def test_loop_reconstruction(self):
        """Test loop reconstruction"""

        # input parameter
        pdbfile = self.get_input_file_name(
            "loop_reconstruction/starting.structure.pdb")
        fastafile = self.get_input_file_name(
            "loop_reconstruction/sequence.fasta")
        sequences = IMP.pmi.topology.Sequences(fastafile)

        # create the representation
        log_objects = []
        optimizable_objects = []

        sw = tools.Stopwatch()
        log_objects.append(sw)

        m = IMP.Model()
        s = IMP.pmi.topology.System(m)
        st = s.create_state()

        cA = st.create_molecule("chainA", sequence=sequences[0])
        atomic = cA.add_structure(pdbfile, chain_id='A')
        cA.add_representation(atomic, resolutions=[1, 10], color=0.)
        cA.add_representation(cA.get_non_atomic_residues(),
                              resolutions=[1],
                              color=0.)

        cB = st.create_molecule("chainB", sequence=sequences[0])
        atomic = cB.add_structure(pdbfile, chain_id='B')
        cB.add_representation(atomic, resolutions=[1, 10], color=0.5)
        cB.add_representation(cB.get_non_atomic_residues(),
                              resolutions=[1],
                              color=0.)
        root_hier = s.build()

        dof = IMP.pmi.dof.DegreesOfFreedom(m)
        dof.create_rigid_body(cA)
        dof.create_rigid_body(cB)

        cr = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(
            root_hier)
        cr.add_to_model()
        log_objects.append(cr)

        listofexcludedpairs = []

        lof = [
            cA[:12], cB[:12], cA[293:339], cB[293:339], cA[685:701],
            cB[685:701], cA[453:464], cB[453:464], cA[471:486], cB[471:486],
            cA[813:859], cB[813:859]
        ]

        # add bonds and angles
        for l in lof:

            print(l)
            rbr = IMP.pmi.restraints.stereochemistry.ResidueBondRestraint(
                objects=l)
            rbr.add_to_model()
            listofexcludedpairs += rbr.get_excluded_pairs()
            log_objects.append(rbr)

            rar = IMP.pmi.restraints.stereochemistry.ResidueAngleRestraint(
                objects=l)
            rar.add_to_model()
            listofexcludedpairs += rar.get_excluded_pairs()
            log_objects.append(rar)

        # add excluded volume

        ev = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(
            included_objects=root_hier, resolution=10.0)
        ev.add_excluded_particle_pairs(listofexcludedpairs)
        ev.add_to_model()
        log_objects.append(ev)

        mc = samplers.MonteCarlo(m, dof.get_movers(), 1.0)
        log_objects.append(mc)

        o = output.Output()

        print("Starting test")
        o.write_test("test.current.dict", log_objects)
        o.test(
            self.get_input_file_name(
                "loop_reconstruction/test.IMP-ee1763c6.PMI-4669cfca.dict"),
            log_objects)
        os.unlink('test.current.dict')
Exemple #34
0
output_objects.append(mr)

# For visualization purposes
mr.create_membrane_density()

###########################
# External barrier
###########################
eb = IMP.pmi.restraints.basic.ExternalBarrier(hierarchies=hier, radius=50)
eb.add_to_model()

##############################
# Shuffle
##############################
IMP.pmi.tools.shuffle_configuration(hier, max_translation=300)
print(dof.get_movers())

##############################
# Sampling
##############################

frames = 10 if IMP.get_is_quick_test() else 2000
rex = IMP.pmi.macros.ReplicaExchange0(
    model,
    root_hier=hier,
    crosslink_restraints=rmf_restraints,
    monte_carlo_sample_objects=dof.get_movers(),
    replica_exchange_maximum_temperature=3.0,
    global_output_directory="output/",
    output_objects=output_objects,
    monte_carlo_steps=10,
Exemple #35
0
### Excluded volume - one for each state (they don't interact)
evr1 = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(included_objects = (m1A,m1B,m1C))
evr1.add_to_model()
output_objects.append(evr1)
evr2 = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(included_objects = (m2A,m2C))
evr2.add_to_model()
output_objects.append(evr2)

###################### SAMPLING #####################
# randomize particles a bit
IMP.pmi.tools.shuffle_configuration(root_hier,
                                    max_translation=20)

# Shift state 2
# Even though the two states don't interact,
#  it'll be easier to look at the RMF if we separate them
trans = IMP.algebra.Transformation3D([50,0,0])
for fb in IMP.core.get_leaves(m2A.get_hierarchy())+IMP.core.get_leaves(m2C.get_hierarchy()):
    IMP.core.transform(IMP.core.XYZ(fb),trans)

# Run replica exchange Monte Carlo sampling
rex=IMP.pmi.macros.ReplicaExchange0(mdl,
                                    root_hier=root_hier,                          # pass the root hierarchy
                                    crosslink_restraints=rmf_restraints,          # will display as springs
                                    monte_carlo_sample_objects=dof.get_movers(),  # pass MC movers
                                    global_output_directory='ambiguity_output/',
                                    output_objects=output_objects,
                                    monte_carlo_steps=10,
                                    number_of_frames=1)     # increase number of frames to get better results!
rex.execute_macro()
    def test_restraint_probability_beads(self):
        """Test restraint works for all-bead systems"""
        for i in range(2):
            m = IMP.Model()
            if i==0:
                rbeads=self.init_representation_beads(m)
                xlbeads,cldb=self.setup_crosslinks_beads(rbeads,"single_category")
            else:
                rbeads,dof=self.init_representation_beads_pmi2(m)
                xlbeads,cldb=self.setup_crosslinks_beads(root_hier=rbeads,mode="single_category")
                self.assertEqual(len(dof.get_movers()),60)
                dof.get_nuisances_from_restraint(xlbeads)
                self.assertEqual(len(dof.get_movers()),62)
            for xl in xlbeads.xl_list:

                chain1 = xl[cldb.protein1_key]
                chain2 = xl[cldb.protein2_key]
                res1 =  xl[cldb.residue1_key]
                res2 =  xl[cldb.residue2_key]
                ids =   xl[cldb.unique_id_key]

            # randomize coordinates and check that the probability is OK
            print("testing PMI version "+str(i+1))
            for j in range(100):
                if i==0:
                    rbeads.shuffle_configuration(max_translation=10)
                else:
                    IMP.pmi.tools.shuffle_configuration(rbeads,max_translation=10)
                cross_link_dict={}
                for xl in xlbeads.xl_list:
                    p0 = xl["Particle1"]
                    p1 = xl["Particle2"]
                    prob = xl["Restraint"].get_probability()
                    resid1 = xl[cldb.residue1_key]
                    chain1 = xl[cldb.protein1_key]
                    resid2 = xl[cldb.residue2_key]
                    chain2 = xl[cldb.protein2_key]
                    xlid=xl[cldb.unique_id_key]
                    d0 = IMP.core.XYZ(p0)
                    d1 = IMP.core.XYZ(p1)
                    sig1 = xl["Particle_sigma1"]
                    sig2 = xl["Particle_sigma2"]
                    psi =  xl["Particle_psi"]

                    if xlid not in cross_link_dict:
                        cross_link_dict[xlid]=([d0],[d1],[sig1],[sig2],[psi],prob)
                    else:
                        cross_link_dict[xlid][0].append(d0)
                        cross_link_dict[xlid][1].append(d1)
                        cross_link_dict[xlid][2].append(sig1)
                        cross_link_dict[xlid][3].append(sig2)
                        cross_link_dict[xlid][4].append(psi)

                for xlid in cross_link_dict:
                    test_prob=get_probability(cross_link_dict[xlid][0],
                                              cross_link_dict[xlid][1],
                                              cross_link_dict[xlid][2],
                                              cross_link_dict[xlid][3],
                                              cross_link_dict[xlid][4],21.0,0.01)
                    prob=cross_link_dict[xlid][5]

                    self.assertAlmostEqual(test_prob,prob, delta=0.0001)
            if i==0:
                rex0 = IMP.pmi.macros.ReplicaExchange0(m,
                                                       rbeads,
                                                       monte_carlo_sample_objects=[rbeads],
                                                       number_of_frames=2,
                                                       test_mode=True,
                                                       replica_exchange_object = rem)
                rex0.execute_macro()
            else:
                rex = IMP.pmi.macros.ReplicaExchange0(m,
                                                      root_hier=rbeads,
                                                      monte_carlo_sample_objects=dof.get_movers(),
                                                      number_of_frames=2,
                                                      test_mode=True,
                                                      replica_exchange_object = rem)
                rex.execute_macro()
            for output in ['excluded.None.xl.db',
                           'included.None.xl.db', 'missing.None.xl.db']:
                os.unlink(output)
Exemple #37
0
    def test_restraint_probability_complex(self):
        """Test restraint gets correct probabilities"""
        m = IMP.Model()
        rcomplex, dof = self.init_representation_complex_pmi2(m)
        xlc, cldb = self.setup_crosslinks_complex(root_hier=rcomplex,
                                                  mode="single_category")
        self.assertEqual(len(dof.get_movers()), 42)
        dof.get_nuisances_from_restraint(xlc)
        self.assertEqual(len(dof.get_movers()), 44)
        # check all internals didn't change since last time
        o = IMP.pmi.output.Output()
        o.write_test("expensive_test_new_cross_link_ms_restraint.dat", [xlc])

        passed = o.test(
            self.get_input_file_name(
                "expensive_test_new_cross_link_ms_restraint.dat"), [xlc])
        self.assertEqual(passed, True)
        rs = xlc.get_restraint()

        # check the probability of cross-links
        restraints = []
        for xl in xlc.xl_list:
            p0 = xl["Particle1"]
            p1 = xl["Particle2"]
            prob = xl["Restraint"].get_probability()
            resid1 = xl[cldb.residue1_key]
            chain1 = xl[cldb.protein1_key]
            resid2 = xl[cldb.residue2_key]
            chain2 = xl[cldb.protein2_key]
            d0 = IMP.core.XYZ(p0)
            d1 = IMP.core.XYZ(p1)
            sig1 = xl["Particle_sigma1"]
            sig2 = xl["Particle_sigma2"]
            psi = xl["Particle_psi"]
            d0 = IMP.core.XYZ(p0)
            d1 = IMP.core.XYZ(p1)
            dist = IMP.core.get_distance(d0, d1)

            test_prob = get_probability([d0], [d1], [sig1], [sig2], [psi],
                                        21.0, 0.0)
            restraints.append(xl["Restraint"])

            # check that the probability is the same for
            # each cross-link
            self.assertAlmostEqual(prob, test_prob, delta=0.00001)

        # check the log_wrapper
        log_wrapper_score = rs.unprotected_evaluate(None)
        test_log_wrapper_score = log_evaluate(restraints)
        self.assertAlmostEqual(log_wrapper_score,
                               test_log_wrapper_score,
                               delta=0.00001)
        rex = IMP.pmi.macros.ReplicaExchange0(
            m,
            root_hier=rcomplex,
            monte_carlo_sample_objects=dof.get_movers(),
            number_of_frames=2,
            test_mode=True,
            replica_exchange_object=rem)
        rex.execute_macro()
        for output in [
                'excluded.None.xl.db',
                'expensive_test_new_cross_link_ms_restraint.dat',
                'included.None.xl.db', 'missing.None.xl.db'
        ]:
            os.unlink(output)
Exemple #38
0
    included_objects=(m1A, m1B, m1C))
evr1.add_to_model()
output_objects.append(evr1)
evr2 = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(
    included_objects=(m2A, m2C))
evr2.add_to_model()
output_objects.append(evr2)

###################### SAMPLING #####################
# randomize particles a bit
IMP.pmi.tools.shuffle_configuration(root_hier, max_translation=20)

# Shift state 2
# Even though the two states don't interact,
#  it'll be easier to look at the RMF if we separate them
trans = IMP.algebra.Transformation3D([50, 0, 0])
for fb in IMP.core.get_leaves(m2A.get_hierarchy()) + IMP.core.get_leaves(
        m2C.get_hierarchy()):
    IMP.core.transform(IMP.core.XYZ(fb), trans)

# Run replica exchange Monte Carlo sampling
rex = IMP.pmi.macros.ReplicaExchange0(
    mdl,
    root_hier=root_hier,  # pass the root hierarchy
    monte_carlo_sample_objects=dof.get_movers(),  # pass MC movers
    global_output_directory='ambiguity_output/',
    output_objects=output_objects,
    monte_carlo_steps=10,
    number_of_frames=1)  # increase number of frames to get better results!
rex.execute_macro()
Exemple #39
0
output_objects.append(mr)

# For visualization purposes
mr.create_membrane_density()

###########################
# External barrier
###########################
eb = IMP.pmi.restraints.basic.ExternalBarrier(hierarchies=hier, radius=50)
eb.add_to_model()

##############################
# Shuffle
##############################
IMP.pmi.tools.shuffle_configuration(hier, max_translation=300)
print(dof.get_movers())

##############################
# Sampling
##############################

frames = 10 if IMP.get_is_quick_test() else 2000
rex = IMP.pmi.macros.ReplicaExchange0(model,
                                      root_hier=hier,
                                      crosslink_restraints=rmf_restraints,
                                      monte_carlo_sample_objects=dof.get_movers(),
                                      replica_exchange_maximum_temperature=3.0,
                                      global_output_directory="output/",
                                      output_objects=output_objects,
                                      monte_carlo_steps=10,
                                      number_of_frames=frames,
    def test_restraint_probability_complex(self):
        """Test restraint gets correct probabilities"""
        for i in range(2):
            m = IMP.Model()
            print("Testing PMI version",i+1)
            if i==0:
                rcomplex = self.init_representation_complex(m)
                xlc,cldb = self.setup_crosslinks_complex(rcomplex,"single_category")
            else:
                rcomplex,dof=self.init_representation_complex_pmi2(m)
                xlc,cldb = self.setup_crosslinks_complex(root_hier=rcomplex,
                                                         mode="single_category")
                self.assertEqual(len(dof.get_movers()),42)
                dof.get_nuisances_from_restraint(xlc)
                self.assertEqual(len(dof.get_movers()),44)
            # check all internals didn't change since last time
            o=IMP.pmi.output.Output()
            o.write_test("expensive_test_new_cross_link_ms_restraint.dat", [xlc])

            passed=o.test(self.get_input_file_name("expensive_test_new_cross_link_ms_restraint.dat"),
                          [xlc])
            self.assertEqual(passed, True)
            rs = xlc.get_restraint()

            # check the probability of cross-links
            restraints=[]
            for xl in xlc.xl_list:
                p0 = xl["Particle1"]
                p1 = xl["Particle2"]
                prob = xl["Restraint"].get_probability()
                resid1 = xl[cldb.residue1_key]
                chain1 = xl[cldb.protein1_key]
                resid2 = xl[cldb.residue2_key]
                chain2 = xl[cldb.protein2_key]
                d0 = IMP.core.XYZ(p0)
                d1 = IMP.core.XYZ(p1)
                sig1 = xl["Particle_sigma1"]
                sig2 = xl["Particle_sigma2"]
                psi =  xl["Particle_psi"]
                d0 = IMP.core.XYZ(p0)
                d1 = IMP.core.XYZ(p1)
                dist=IMP.core.get_distance(d0, d1)

                test_prob=get_probability([d0],[d1],[sig1],[sig2],[psi],21.0,0.0)
                restraints.append(xl["Restraint"])

                # check that the probability is the same for
                # each cross-link
                self.assertAlmostEqual(prob, test_prob, delta=0.00001)

            # check the log_wrapper
            log_wrapper_score=rs.unprotected_evaluate(None)
            test_log_wrapper_score=log_evaluate(restraints)
            self.assertAlmostEqual(log_wrapper_score, test_log_wrapper_score, delta=0.00001)
            if i==0:
                rex0 = IMP.pmi.macros.ReplicaExchange0(m,
                                                       rcomplex,
                                                       monte_carlo_sample_objects=[rcomplex],
                                                       number_of_frames=2,
                                                       test_mode=True,
                                                       replica_exchange_object = rem)
                rex0.execute_macro()
            else:
                rex = IMP.pmi.macros.ReplicaExchange0(m,
                                                      root_hier=rcomplex,
                                                      monte_carlo_sample_objects=dof.get_movers(),
                                                      number_of_frames=2,
                                                      test_mode=True,
                                                      replica_exchange_object = rem)
                rex.execute_macro()
            for output in ['excluded.None.xl.db',
                           'expensive_test_new_cross_link_ms_restraint.dat',
                           'included.None.xl.db', 'missing.None.xl.db']:
                os.unlink(output)
Exemple #41
0
    def test_multistate(self):
        psiv = 0.01
        sigmav = 12.0
        slope = 0.0
        length = 21
        inputx = 70

        m = IMP.Model()
        s = IMP.pmi.topology.System(m)

        # define the particles in state 1
        st1 = s.create_state()
        mol1 = []
        for mn in range(1, 4):
            mol = st1.create_molecule("particle%d" % mn, "G" * 10,
                                      "ABC"[mn - 1])
            mol.add_representation(resolutions=[10])
            mol1.append(mol)

        # define the particles in state 2
        st2 = s.create_state()
        mol2 = []
        for mn in range(1, 4):
            mol = st2.create_molecule("particle%d" % mn, "G" * 10,
                                      "ABC"[mn - 1])
            mol.add_representation(resolutions=[10])
            mol2.append(mol)

        hier = s.build()

        dof = IMP.pmi.dof.DegreesOfFreedom(m)

        # only allow particle3 in each state to move
        dof.create_flexible_beads(mol1[2])
        dof.create_flexible_beads(mol2[2])

        pp1, pp2, pp3 = IMP.atom.get_leaves(st1.hier)

        xyz11 = IMP.core.XYZ(pp1)
        xyz21 = IMP.core.XYZ(pp2)
        xyz31 = IMP.core.XYZ(pp3)
        xyz11.set_coordinates((0, 0, 0))
        print(xyz11.get_coordinates())
        xyz21.set_coordinates((inputx, 0, 0))
        xyz31.set_coordinates((0, 0, 0))

        pp1, pp2, pp3 = IMP.atom.get_leaves(st2.hier)
        xyz12 = IMP.core.XYZ(pp1)
        xyz22 = IMP.core.XYZ(pp2)
        xyz32 = IMP.core.XYZ(pp3)
        xyz12.set_coordinates((0, 0, 0))
        xyz22.set_coordinates((inputx, 0, 0))
        xyz32.set_coordinates((inputx, 0, 0))

        eb = IMP.pmi.restraints.basic.ExternalBarrier(hierarchies=st1.hier,
                                                      radius=1000)
        eb.add_to_model()

        eb = IMP.pmi.restraints.basic.ExternalBarrier(hierarchies=st2.hier,
                                                      radius=1000)
        eb.add_to_model()

        xldbkwc = IMP.pmi.io.crosslink.CrossLinkDataBaseKeywordsConverter()
        xldbkwc.set_protein1_key("prot1")
        xldbkwc.set_protein2_key("prot2")
        xldbkwc.set_residue1_key("res1")
        xldbkwc.set_residue2_key("res2")
        xldbkwc.set_unique_id_key("id")

        cldb = IMP.pmi.io.crosslink.CrossLinkDataBase(xldbkwc)
        cldb.create_set_from_file(self.get_input_file_name('multistate.csv'))

        xl = IMP.pmi.restraints.crosslinking.CrossLinkingMassSpectrometryRestraint(
            root_hier=hier,
            database=cldb,
            length=length,
            slope=slope,
            resolution=1.0)

        psi = xl.psi_dictionary['PSI'][0]
        psi.set_scale(psiv)

        sigma = xl.sigma_dictionary['SIGMA'][0]
        sigma.set_scale(sigmav)

        xl.set_psi_is_sampled(False)
        xl.set_sigma_is_sampled(False)

        # psi.set_scale(0.1)
        # xl.get_sigma(1.0)

        out_dict = xl.get_output()
        sorted_keys = sorted(out_dict.keys())
        for entry in sorted_keys:
            print(entry, out_dict[entry])

        print(xyz11.get_coordinates())

        xl.add_to_model()
        rset = IMP.pmi.tools.get_restraint_set(m)
        self.assertAlmostEqual(rset.evaluate(False), -3.03166, delta=1e-2)

        o = IMP.pmi.output.Output()
        o.init_rmf("trajectory.rmf3", [st1.hier, st2.hier])

        print(o.dictionary_rmfs)

        mc = IMP.pmi.samplers.MonteCarlo(m, dof.get_movers(), 1.0)
        mc.set_simulated_annealing(min_temp=1.0,
                                   max_temp=2.0,
                                   min_temp_time=200,
                                   max_temp_time=50)

        o.init_stat2("modeling.stat", [mc, xl])

        for i in range(1, 20):
            xyz31.set_coordinates((float(i), 0, 0))
            for j in range(1, 20):
                xyz32.set_coordinates((float(j), 0, 0))
                print(i, j, rset.evaluate(False))
                o.write_stats2()

        po = IMP.pmi.output.ProcessOutput("modeling.stat")
        print(po.get_keys())

        self.assertEqual(len(po.get_keys()), 14)

        fs = po.get_fields([
            'CrossLinkingMassSpectrometryRestraint_Distance_||2.1|particle1|5|particle3|5|1|PSI|',
            'CrossLinkingMassSpectrometryRestraint_Distance_||1.1|particle2|5|particle3|5|1|PSI|',
            'CrossLinkingMassSpectrometryRestraint_Data_Score',
            'CrossLinkingMassSpectrometryRestraint_Linear_Score',
            'CrossLinkingMassSpectrometryRestraint_Psi_PSI'
        ])
        print(fs.keys())
        o.close_rmf("trajectory.rmf3")

        for output in [
                'excluded.None.xl.db', 'included.None.xl.db',
                'missing.None.xl.db', 'modeling.stat', 'trajectory.rmf3'
        ]:
            os.unlink(output)
Exemple #42
0
    def test_restraint_probability_beads(self):
        """Test restraint works for all-bead systems"""
        m = IMP.Model()
        rbeads, dof = self.init_representation_beads_pmi2(m)
        xlbeads, cldb = self.setup_crosslinks_beads(root_hier=rbeads,
                                                    mode="single_category")
        self.assertEqual(len(dof.get_movers()), 60)
        dof.get_nuisances_from_restraint(xlbeads)
        self.assertEqual(len(dof.get_movers()), 62)
        for xl in xlbeads.xl_list:

            chain1 = xl[cldb.protein1_key]
            chain2 = xl[cldb.protein2_key]
            res1 = xl[cldb.residue1_key]
            res2 = xl[cldb.residue2_key]
            ids = xl[cldb.unique_id_key]

        # randomize coordinates and check that the probability is OK
        for j in range(100):
            IMP.pmi.tools.shuffle_configuration(rbeads, max_translation=10)
            cross_link_dict = {}
            for xl in xlbeads.xl_list:
                p0 = xl["Particle1"]
                p1 = xl["Particle2"]
                prob = xl["Restraint"].get_probability()
                resid1 = xl[cldb.residue1_key]
                chain1 = xl[cldb.protein1_key]
                resid2 = xl[cldb.residue2_key]
                chain2 = xl[cldb.protein2_key]
                xlid = xl[cldb.unique_id_key]
                d0 = IMP.core.XYZ(p0)
                d1 = IMP.core.XYZ(p1)
                sig1 = xl["Particle_sigma1"]
                sig2 = xl["Particle_sigma2"]
                psi = xl["Particle_psi"]

                if xlid not in cross_link_dict:
                    cross_link_dict[xlid] = ([d0], [d1], [sig1], [sig2], [psi],
                                             prob)
                else:
                    cross_link_dict[xlid][0].append(d0)
                    cross_link_dict[xlid][1].append(d1)
                    cross_link_dict[xlid][2].append(sig1)
                    cross_link_dict[xlid][3].append(sig2)
                    cross_link_dict[xlid][4].append(psi)

            for xlid in cross_link_dict:
                test_prob = get_probability(cross_link_dict[xlid][0],
                                            cross_link_dict[xlid][1],
                                            cross_link_dict[xlid][2],
                                            cross_link_dict[xlid][3],
                                            cross_link_dict[xlid][4], 21.0,
                                            0.01)
                prob = cross_link_dict[xlid][5]

                self.assertAlmostEqual(test_prob, prob, delta=0.0001)
        rex = IMP.pmi.macros.ReplicaExchange0(
            m,
            root_hier=rbeads,
            monte_carlo_sample_objects=dof.get_movers(),
            number_of_frames=2,
            test_mode=True,
            replica_exchange_object=rem)
        rex.execute_macro()
        for output in [
                'excluded.None.xl.db', 'included.None.xl.db',
                'missing.None.xl.db'
        ]:
            os.unlink(output)
Exemple #43
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