def test_xlinks(self): """ Test the Xlinks class """ for p in self.pairs: xlist = self.xlinks.get_xlinks_for_pair(p) # build manually the list that xlist should build manual_xlist = [] xl = None for c in self.crosslinks: if p == (c[0], c[3]) or p == (c[3], c[0]): xl = bx.Xlink(*c) if p == (c[3], c[0]): xl.swap() manual_xlist.append(xl) # check the number of crosslinks for the pair self.assertEqual(len(manual_xlist), len(xlist)) # check amino acids and distances aa = [(xl.first_residue, xl.second_residue, xl.distance) for xl in xlist] ll = [(xl.first_residue, xl.second_residue, xl.distance) for xl in manual_xlist] for x in ll: self.assertTrue(x in aa) xlistDE = self.xlinks.get_xlinks_for_pair(("subunitD", "subunitE")) xlistED = self.xlinks.get_xlinks_for_pair(("subunitE", "subunitD")) self.assertEqual(len(xlistDE), 4) self.assertEqual(len(xlistED), 4) for y, x in zip(xlistDE, xlistED): self.assertEqual(x.first_residue, y.second_residue) self.assertEqual(y.first_residue, x.second_residue) self.assertEqual(x.distance, y.distance)
def setUp(self): IMP.test.TestCase.setUp(self) if bx is None: self.skipTest(bxerr) self.crosslinks = [ ("subunitA", "A", 1, "subunitB", "B", 1, 10), ("subunitA", "A", 2, "subunitB", "B", 2, 20), ("subunitB", "B", 3, "subunitA", "A", 3, 30), ("subunitB", "B", 4, "subunitC", "C", 1, 40), ("subunitB", "B", 5, "subunitC", "C", 2, 20), ("subunitD", "D", 6, "subunitC", "C", 1, 10), ("subunitC", "C", 3, "subunitD", "D", 2, 70), ("subunitC", "C", 4, "subunitD", "D", 3, 80), ("subunitD", "D", 4, "subunitE", "E", 1, 10), ("subunitE", "E", 5, "subunitD", "D", 2, 30), ("subunitD", "D", 6, "subunitE", "E", 3, 40), ("subunitD", "D", 7, "subunitE", "E", 4, 50), ] # get different pairs of subunits self.xlinks = bx.XlinksDict() for c in self.crosslinks: x = bx.Xlink(*c) self.xlinks.add(x) self.pairs = set() for c in self.crosslinks: self.pairs.add((c[0], c[3]))
def set_xlink_restraint(self, id1, chain1, residue1, id2, chain2, residue2, distance, weight, stddev, max_score=False): """ Set a restraint on the maximum distance between 2 residues @param id1 Name of the first component @param chain1 @param residue1 Residue number for the aminoacid in the first component.The number is the number in the PDB file, not the number relative to the beginning of the chain @param id2 Name of the second component @param chain2 @param residue2 Residue number for the aminoacid in the second component. @param distance Maximum distance tolerated @param weight Weight of the restraint @param stddev Standard deviation used to approximate the HarmonicUpperBound function to a Gaussian @param max_score See help for add_restraint(). If none is given, the maximum score is set to allow a maximum distance of 10 Angstrom greater than the parameter "distance". """ xlink = buildxlinks.Xlink( id1, chain1, residue1, id2, chain2, residue2, distance) log.info("Setting cross-linking restraint ") log.info("%s", xlink.show()) self.xlinks_dict.add(xlink) # setup restraint A = representation.get_component(self.assembly, xlink.first_id) s1 = IMP.atom.Selection(A, chain=xlink.first_chain, residue_index=xlink.first_residue) p1 = s1.get_selected_particles()[0] B = representation.get_component(self.assembly, xlink.second_id) s2 = IMP.atom.Selection(B, chain=xlink.second_chain, residue_index=xlink.second_residue) p2 = s2.get_selected_particles()[0] k = core.Harmonic.get_k_from_standard_deviation(stddev) score = core.HarmonicUpperBound(xlink.distance, k) pair_score = IMP.core.DistancePairScore(score) r = IMP.core.PairRestraint(pair_score, IMP.ParticlePair(p1, p2)) if not max_score: error_distance_allowed = 100 max_score = weight * \ score.evaluate(distance + error_distance_allowed) log.info("%s, max_score %s", xlink.show(), max_score) self.add_restraint(r, xlink.get_name(), weight, max_score)
def test_filter_transformations(self): """ Check if the filtered conformation are the conformations that I computed before """ try: import subprocess import IMP.EMageFit.buildxlinks as bx except ImportError as e: self.skipTest(str(e)) dock = self.import_python_application('emagefit_dock') sel = atom.NonWaterNonHydrogenPDBSelector() ligand = IMP.kernel.Model() fn_ligand = self.get_input_file_name("3sfdB-3sfdA_initial_docking.pdb") h_ligand = atom.read_pdb(fn_ligand, ligand, sel) rb_ligand = atom.create_rigid_body(h_ligand) receptor = IMP.kernel.Model() fn_receptor = self.get_input_file_name("3sfdB.pdb") h_receptor = atom.read_pdb(fn_receptor, receptor, sel) # read_hex_transformations fn = self.get_input_file_name("hex_solutions_3sfdB-3sfdA.txt") residue_receptor = 23 residue_ligand = 456 distance = 30 xl = bx.Xlink("3sfdB", "B", residue_receptor, "3sfdA", "A", residue_ligand, distance) xlinks_list = [xl] fn_filtered = "filtered_transforms.txt" dock.filter_docking_results(h_receptor, h_ligand, xlinks_list, fn, fn_filtered) fn_stored = self.get_input_file_name( "hex_solutions_3sfdB-3sfdA_filtered.txt") filtered = dock.read_hex_transforms(fn_filtered) stored = dock.read_hex_transforms(fn_stored) # check that the filtered transforms match the stored ones self.assertEqual(len(filtered), len(stored)) for Tf, Ts in zip(filtered, stored): tf = Tf.get_translation() ts = Ts.get_translation() qf = Tf.get_rotation().get_quaternion() qs = Ts.get_rotation().get_quaternion() for k in range(3): self.assertAlmostEqual(tf[k], ts[k]) for k in range(4): self.assertAlmostEqual(qf[k], qs[k]) os.remove(fn_filtered)
def setUp(self): IMP.test.TestCase.setUp(self) if bx is None: self.skipTest(bxerr) self.max_distance = 30 self.crosslinks = [ ("3sfdB", "B", 23, "3sfdA", "A", 456, self.max_distance), ("3sfdB", "B", 241, "3sfdC", "C", 112, self.max_distance), ("3sfdB", "B", 205, "3sfdD", "D", 37, self.max_distance), ("3sfdB", "B", 177, "3sfdD", "D", 99, self.max_distance), ("3sfdC", "C", 9, "3sfdD", "D", 37, self.max_distance), ("3sfdC", "C", 78, "3sfdD", "D", 128, self.max_distance), ] self.xlinks = bx.XlinksDict() for c in self.crosslinks: self.xlinks.add(bx.Xlink(*c))
def test_build_order(self): """ Test the order recommendation for the xlinks """ # Note that we don't use the same crosslinks here as the other tests, # because the order recommendation doesn't take account of multiple # crosslinks between a given pair of subunits. crosslinks = [ ("subunitA", "A", 1, "subunitB", "B", 1, 10), ("subunitA", "A", 1, "subunitC", "B", 1, 10), ("subunitA", "A", 1, "subunitD", "B", 1, 10), ("subunitA", "A", 1, "subunitE", "B", 1, 10), ("subunitA", "A", 1, "subunitF", "B", 1, 10), ("subunitC", "A", 1, "subunitE", "B", 1, 10), ("subunitC", "A", 1, "subunitD", "B", 1, 10), ("subunitB", "A", 1, "subunitF", "B", 1, 10), ] xlinks = bx.XlinksDict() for c in crosslinks: xlinks.add(bx.Xlink(*c)) dock_order = bx.DockOrder() dock_order.set_xlinks(xlinks) docking_pairs = dock_order.get_docking_order() # Optimal order should be: # - First, pick the most linked subunit (A) and dock everything # that's linked to it (in any order) # - Repeat with the remaining subunits in order of most links (C, B) optimal_order = [('subunitA', 'subunitB'), ('subunitA', 'subunitC'), ('subunitA', 'subunitD'), ('subunitA', 'subunitE'), ('subunitA', 'subunitF'), ('subunitC', 'subunitD'), ('subunitC', 'subunitE'), ('subunitF', 'subunitB')] docking_pairs = sorted(docking_pairs[:5]) + sorted(docking_pairs[5:7]) \ + [docking_pairs[7]] for p, q in zip(docking_pairs, optimal_order): self.assertEqual(p, q)