def init_representation_beads_pmi2(self, m): s = IMP.pmi.topology.System(m) st = s.create_state() protA = st.create_molecule("ProtA", sequence='A' * 30, chain_id='A') protA.add_representation(protA[0:10], resolutions=[1], bead_default_coord=[0, 0, 0]) protA.add_representation(protA[10:20], resolutions=[1], bead_default_coord=[10, 0, 0]) protA.add_representation(protA[20:30], resolutions=[1], bead_default_coord=[20, 0, 0]) protB = st.create_molecule("ProtB", sequence='A' * 30, chain_id='B') protB.add_representation(protB[0:10], resolutions=[1], bead_default_coord=[0, 0, 0]) protB.add_representation(protB[10:20], resolutions=[1], bead_default_coord=[10, 0, 0]) protB.add_representation(protB[20:30], resolutions=[1], bead_default_coord=[20, 0, 0]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) dof.create_flexible_beads(protA) dof.create_flexible_beads(protB) return hier, dof
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)
def test_mc_flexible_beads3(self): """Test flex beads don't work if nothing passed""" mdl = IMP.Model() s,mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) fb_movers = dof.create_flexible_beads(mols[1].get_non_atomic_residues(),max_trans=1.0) self.assertEqual(len(fb_movers),0)
def init_representation_beads_pmi2(self,m): s = IMP.pmi.topology.System(m) st = s.create_state() protA = st.create_molecule("ProtA",sequence='A'*30,chain_id='A') protA.add_representation(protA[0:10],resolutions=[1],bead_default_coord=[0,0,0]) protA.add_representation(protA[10:20],resolutions=[1],bead_default_coord=[10,0,0]) protA.add_representation(protA[20:30],resolutions=[1],bead_default_coord=[20,0,0]) protB = st.create_molecule("ProtB",sequence='A'*30,chain_id='B') protB.add_representation(protB[0:10],resolutions=[1],bead_default_coord=[0,0,0]) protB.add_representation(protB[10:20],resolutions=[1],bead_default_coord=[10,0,0]) protB.add_representation(protB[20:30],resolutions=[1],bead_default_coord=[20,0,0]) hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) dof.create_flexible_beads(protA) dof.create_flexible_beads(protB) return hier,dof
def test_mc_flexible_beads3(self): """Test flex beads don't work if nothing passed""" mdl = IMP.Model() s, mols = self.init_topology3(mdl) dof = IMP.pmi.dof.DegreesOfFreedom(mdl) fb_movers = dof.create_flexible_beads( mols[1].get_non_atomic_residues(), max_trans=1.0) self.assertEqual(len(fb_movers), 0)
def test_mc_flexible_beads(self): 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]) fbs = dof.create_flexible_beads(sel_nonrigid, max_trans=1.0) mvs = fbs.get_movers() self.assertEqual(len(mvs), 3)
def test_mc_flexible_beads(self): 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]) fbs = dof.create_flexible_beads(sel_nonrigid,max_trans=1.0) mvs = fbs.get_movers() self.assertEqual(len(mvs),3)
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()
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()
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)
##fname = 'test2.rmf' ##rh = RMF.create_rmf_file(fname) ##IMP.rmf.add_hierarchy(rh, root_hier) ##IMP.rmf.save_frame(rh) ##(receptor_radius,receptor_center_residue)=get_radius_center_residue(receptor) ##(ligand_radius,ligand_center_residue)=get_radius_center_residue(ligand) ##print "radius",receptor_radius +ligand_radius+5.0 ## 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) dof.create_flexible_beads(ligand_mol,max_trans = -1, resolutions_list=resolutions,move_sizes_list = move_sizes) ########################## RESTRAINTS ##################### output_objects = [] # keep a list of functions that need to be reported display_restraints = [] # display as springs in RMF # 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) # Excluded volume - automatically more efficient due to rigid bodies evr1 = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(included_objects = ligand_mol)
# State 2: ProtA (chainA), ProtC (chainC) m2A = st2.create_molecule('ProtA',sequence,chain_id='A') m2A.add_representation(m2A,resolutions=[1]) m2C = st2.create_molecule('ProtC',sequence,chain_id='C') m2C.add_representation(m2C,resolutions=[1]) root_hier = s.build() ### Display all the states, molecules, representations IMP.atom.show_with_representations(root_hier) ### Setup all molecules to move as flexible beads and super rigid bodies # "Super rigid bodies" aren't really rigid, it's just a mover that moves the whole body together dof = IMP.pmi.dof.DegreesOfFreedom(mdl) for mol in (m1A,m1B,m1C,m2A,m2C): dof.create_flexible_beads(mol, max_trans=0.1) dof.create_super_rigid_body(mol) ###################### RESTRAINTS ##################### output_objects = [] # keep a list of functions that need to be reported rmf_restraints = [] # display these restraints as springs in the RMF ### Crosslinks setup # 1) Create file. This one XL has 3 ambiguity options: State1 has 2, State2 has 1 lines = '''id,mol1,res1,mol2,res2,score 1,ProtA,3,ProtC,9,1.0 ''' tf = tempfile.NamedTemporaryFile(delete=False, mode='w') tf.write(lines) tf.close()
def test_restraint_copy_ambiguity(self): """Test restraint works for systems with configuration ambiguity in PMI2""" # setup system m = IMP.Model() s = IMP.pmi.topology.System(m) st = s.create_state() protA = st.create_molecule("ProtA",sequence='A'*30,chain_id='A') protA.add_representation(protA[0:10],resolutions=[1],bead_default_coord=[0,0,0]) protA.add_representation(protA[10:20],resolutions=[1],bead_default_coord=[10,0,0]) protA.add_representation(protA[20:30],resolutions=[1],bead_default_coord=[20,0,0]) protA2 = protA.create_clone('C') protB = st.create_molecule("ProtB",sequence='A'*30,chain_id='B') protB.add_representation(protB[0:10],resolutions=[1],bead_default_coord=[0,0,0]) protB.add_representation(protB[10:20],resolutions=[1],bead_default_coord=[10,0,0]) protB.add_representation(protB[20:30],resolutions=[1],bead_default_coord=[20,0,0]) protB2 = protB.create_clone('D') hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) dof.create_flexible_beads([protA,protA2,protB,protB2]) xlbeads,cldb = self.setup_crosslinks_beads(root_hier=hier,mode="single_category") # check enough clones were created self.assertEqual(len(cldb.data_base['1']),8) self.assertEqual(len(cldb.data_base['2']),4) self.assertEqual(len(cldb.data_base['3']),4) self.assertEqual(len(cldb.data_base['4']),4) # check score for j in range(100): IMP.pmi.tools.shuffle_configuration(hier,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) for output in ['excluded.None.xl.db', 'included.None.xl.db', 'missing.None.xl.db']: os.unlink(output)
for i, mol in enumerate(pol2g_mols): # create a rigid body for each domain with structural information, the flexible beads inside are part of the rigid body, the remaining part of the #crystal structures of RPB1 and RPB2 if i in range(12): print(i, mol) pol2g_unstructured = mol.get_non_atomic_residues() pol2g_structured = mol.get_atomic_residues() pol2g_all = mol.get_residues() pol2g_complex.append(pol2g_all) pol2g_complexn.append(pol2g_unstructured) if i in [12]: pol2g_u = mol.get_non_atomic_residues() pol2g_rigid1 = mol.get_residues() dof.create_flexible_beads(pol2g_rigid1, max_trans=FLEX_MAX_TRANS, resolution=10) print(dof) pol2g_molc2 = [x for x in pol2g_complex] pol2g_molc3 = [x for x in pol2g_complexn] dof.create_flexible_beads(pol2g_molc3, max_trans=FLEX_MAX_TRANS, resolution=10) ############################################################## ############################################################## ############################################################## ############################################################## ############################################################## ####################### RESTRAINTS ##################### output_objects = [] # keep a list of functions that need to be reported
pass sys.stdout = DummyFile() """setting up the representation PMI 2 representation. Creates two particles and an harmonic distance restraints between them""" 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() start_time = process_time() rex = IMP.pmi.macros.ReplicaExchange0( m, root_hier=hier, monte_carlo_sample_objects=dof.get_movers(),
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)
# State 2: ProtA (chainA), ProtC (chainC) m2A = st2.create_molecule('ProtA', sequence, chain_id='A') m2A.add_representation(m2A, resolutions=[1]) m2C = st2.create_molecule('ProtC', sequence, chain_id='C') m2C.add_representation(m2C, resolutions=[1]) root_hier = s.build() ### Display all the states, molecules, representations IMP.atom.show_with_representations(root_hier) ### Setup all molecules to move as flexible beads and super rigid bodies # "Super rigid bodies" aren't really rigid, it's just a mover that moves the whole body together dof = IMP.pmi.dof.DegreesOfFreedom(mdl) for mol in (m1A, m1B, m1C, m2A, m2C): dof.create_flexible_beads(mol, max_trans=0.1) dof.create_super_rigid_body(mol) ###################### RESTRAINTS ##################### output_objects = [] # keep a list of functions that need to be reported ### Crosslinks setup # 1) Create file. This one XL has 3 ambiguity options: State1 has 2, State2 has 1 lines = '''id,mol1,res1,mol2,res2,score 1,ProtA,3,ProtC,9,1.0 ''' tf = tempfile.NamedTemporaryFile(delete=False, mode='w') tf.write(lines) tf.close() # 2) Define the columns
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)
# Create a symmetry constraint # A constrant is invariant: IMP will automatically move all clones to match the reference # If instead you want some more flexiblity, consider IMP.pmi.restraints.stereochemistry.SymmetryRestraint dof = IMP.pmi.dof.DegreesOfFreedom(mdl) center = IMP.algebra.Vector3D([50,0,0]) for nc in range(7): rot = IMP.algebra.get_rotation_about_axis([0,0,1],2*math.pi*(nc+1)/8) transform = IMP.algebra.get_rotation_about_point(center,rot) dof.constrain_symmetry(mols[0],mols[nc+1],transform) mdl.update() # propagates coordinates ############ Make stuff look cool with restraints ########### # set up the original molecule as flexible beads dof.create_flexible_beads(mols[0]) # Create a connectivity restraint for the first molecule cr = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(objects=mol) cr.add_to_model() # Create excluded volume for all particles evr = IMP.pmi.restraints.stereochemistry.ExcludedVolumeSphere(included_objects=mols) evr.add_to_model() # Quickly move all flexible beads into place dof.optimize_flexible_beads(100) # write a single-frame RMF to view the helix out = IMP.pmi.output.Output() out.init_rmf("example_symmetry.rmf3",hierarchies=[hier])
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])
TREM2_mol.append(mol) elif 'Abeta' in molname: crA = IMP.pmi.restraints.stereochemistry.ConnectivityRestraint(mol, scale=2.0) crA.add_to_model() output_objects.append(crA) sample_objects.append(crA) crs.append(crA) atomic = mol.get_atomic_residues() dof.create_rigid_body(atomic, max_trans=0, max_rot=0, resolution='all') dof.create_flexible_beads(mol.get_non_atomic_residues(), max_trans=1.0, resolution=1) active_tri_mol.append(mol) # ______Composite Restraint for Fibril___________________________________________________________________ shuffle_exclude_rbs = dof.get_rigid_bodies()[:-1] # Constrain the fibril trimer unit copies with z-trans. symmetry ### This is very important for i in range(0, len(chains)): for t in range(0, len(fibril_transforms)): threefold_trans = fibril_transforms[t] dof.constrain_symmetry(protofil_mols[i][0], protofil_mols[i][t + 1], threefold_trans) mdl.update() print("||||| All sym constraints added |||||")
def test_restraint_copy_ambiguity(self): """Test restraint works for systems with configuration ambiguity in PMI2""" # setup system m = IMP.Model() s = IMP.pmi.topology.System(m) st = s.create_state() protA = st.create_molecule("ProtA", sequence='A' * 30, chain_id='A') protA.add_representation(protA[0:10], resolutions=[1], bead_default_coord=[0, 0, 0]) protA.add_representation(protA[10:20], resolutions=[1], bead_default_coord=[10, 0, 0]) protA.add_representation(protA[20:30], resolutions=[1], bead_default_coord=[20, 0, 0]) protA2 = protA.create_clone('C') protB = st.create_molecule("ProtB", sequence='A' * 30, chain_id='B') protB.add_representation(protB[0:10], resolutions=[1], bead_default_coord=[0, 0, 0]) protB.add_representation(protB[10:20], resolutions=[1], bead_default_coord=[10, 0, 0]) protB.add_representation(protB[20:30], resolutions=[1], bead_default_coord=[20, 0, 0]) protB2 = protB.create_clone('D') hier = s.build() dof = IMP.pmi.dof.DegreesOfFreedom(m) dof.create_flexible_beads([protA, protA2, protB, protB2]) xlbeads, cldb = self.setup_crosslinks_beads(root_hier=hier, mode="single_category") # check enough clones were created self.assertEqual(len(cldb.data_base['1']), 8) self.assertEqual(len(cldb.data_base['2']), 4) self.assertEqual(len(cldb.data_base['3']), 4) self.assertEqual(len(cldb.data_base['4']), 4) # check score for j in range(100): IMP.pmi.tools.shuffle_configuration(hier, 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) for output in [ 'excluded.None.xl.db', 'included.None.xl.db', 'missing.None.xl.db' ]: os.unlink(output)
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])