def mutable_residues_selector(protease_selection, peptide_selection, catalytic_selection, design_peptide=False): """ Selects the residues in a shell around the peptide using the InterGroupInterfaceByVectorSelector residue selector """ # Making protease shell selector (includes peptide) first_shell_select = InterGroupInterfaceByVectorSelector() first_shell_select.group1_selector(protease_selection) first_shell_select.group2_selector(peptide_selection) first_shell_select.nearby_atom_cut(8) first_shell_select.vector_dist_cut(10) # Excluding the catalytic residues, peptide (if not designed) not_cats_sel = NotResidueSelector(catalytic_selection) if design_peptide: mutable_selection = selector_intersection(not_cats_sel, first_shell_select) else: mutable_selection = selector_intersection(not_cats_sel, first_shell_select, protease_selection) return mutable_selection
def ligand_neighbor_selection(lig, radius, pose, include_ligand=False): rad = float(radius) not_ligand = NotResidueSelector() not_ligand.set_residue_selector(lig) lig_distant_neighbors = InterGroupInterfaceByVectorSelector() lig_distant_neighbors.group1_selector(lig) lig_distant_neighbors.group2_selector(not_ligand) lig_distant_neighbors.cb_dist_cut(2.0 * rad) lig_distant_neighbors.nearby_atom_cut(rad) lig_contacts = pr.rosetta.core.select.residue_selector.CloseContactResidueSelector( ) lig_contacts.central_residue_group_selector(lig) lig_contacts.threshold(rad) lig_neighbors = OrResidueSelector() lig_neighbors.add_residue_selector(lig_distant_neighbors) lig_neighbors.add_residue_selector(lig_contacts) if include_ligand: selection = AndResidueSelector() selection.add_residue_selector(not_ligand) else: selection = OrResidueSelector() selection.add_residue_selector(lig) selection.add_residue_selector(lig_neighbors) return get_residues_from_subset(selection.apply(pose))
def shell_selection(selection_1, selection_2, base_range): shell_select = InterGroupInterfaceByVectorSelector() shell_select.group1_selector(selection_1) shell_select.group2_selector(selection_2) shell_select.nearby_atom_cut(base_range) shell_select.vector_dist_cut(base_range + 2) return AndResidueSelector(shell_select, NotResidueSelector(selection_2))
def check_selection_proximity(pose, selection_1, selection_2): """ Determines whether any residues in one selector are close enough to potentially interact with residues from a second selector, using an InterGroupInterfaceByVector selector with default settings. """ # Make full-pose selection full_pose = TrueResidueSelector() # Make selection for the full pose minus the first selector not_selection_1 = NotResidueSelector(selection_1) full_minus_1 = selector_intersection(full_pose, not_selection_1) # Make selection for interacting residues between selection 1 the rest of the pose igibv = InterGroupInterfaceByVectorSelector() igibv.group1_selector(selection_1) igibv.group2_selector(full_minus_1) # Find intersection of selector_1's interaction partners and selector_2 selection_overlap = selector_intersection(igibv, selection_2) # Check if there are residues in the intersection, or if it is empty # If it is empty, the Boolean will be False. Otherwise, it will be True selections_do_overlap = bool(selector_to_list(pose, selection_overlap)) return selections_do_overlap
def mutable_residues_selector(design_peptide=False, single_pep_res=None): """ Selects the residues in a shell around the peptide using the InterGroupInterfaceByVectorSelector residue selector Presently hard coded for HCV protease. Decided to design just around peptide, not pep + cat, and only the six mutable residues in the peptide. """ # Selecting regions protease = ChainSelector("A") catalytic = ResidueIndexSelector('72,96,154') if single_pep_res: variable_pep_res = ResidueIndexSelector(str(single_pep_res)) else: variable_pep_res = ResidueIndexSelector("198-203") # Making positive residue selector rs = InterGroupInterfaceByVectorSelector() rs.group1_selector(protease) # Protease rs.group2_selector(variable_pep_res) # Peptide recognition region rs.nearby_atom_cut(6) rs.vector_dist_cut(8) # Excluding the catalytic residues limit_selection = AndResidueSelector() limit_selection.add_residue_selector(NotResidueSelector(catalytic)) limit_selection.add_residue_selector(rs) # If the peptide sequence is mutable if design_peptide: return limit_selection # If only the protease is designable else: # Setting up exclusion of catalytic and peptide residues exclusive_selection = AndResidueSelector() exclusive_selection.add_residue_selector(limit_selection) exclusive_selection.add_residue_selector(ChainSelector("A")) return exclusive_selection
def design(self, antibody=True, antigen=False, pack_only=False): self.pose = self.native_pose.clone() info = self.pose.pdb_info() tf = TaskFactory() tf.push_back(operation.InitializeFromCommandline()) epi_res = '' for res in self.epitopes_pose: epi_res += '{0},'.format(res) epi_selector = ResidueIndexSelector(epi_res) antibody_selector = ChainSelector() vec = vector1_std_string() for chain in self.antibody: vec.append(chain) vec.append(chain) antibody_selector.set_chain_strings(vec) interface_res_selector = InterGroupInterfaceByVectorSelector( epi_selector, antibody_selector) interface_antibody_selector = AndResidueSelector( interface_res_selector, antibody_selector) if pack_only: tf.push_back(operation.RestrictToRepacking()) else: if antigen: design_selector = epi_selector elif antibody: design_selector = interface_antibody_selector # FIRST select designable residues and prevent everything else from design and packing no_design_selector = NotResidueSelector(design_selector) prevent_repacking_rlt = operation.PreventRepackingRLT() #restrict_topack = operation.RestrictToRepackingRLT() prevent_design = operation.OperateOnResidueSubset( prevent_repacking_rlt, no_design_selector, False) tf.push_back(prevent_design) print(tf.create_task_and_apply_taskoperations(self.pose)) packer = pack_min.PackRotamersMover('ref2015') packer.task_factory(tf) packer.apply(self.pose)
def detect_inter_group_interface(pose, chains): protein_selector = ResiduePropertySelector(ResidueProperty.PROTEIN) group1_selector = AndResidueSelector(ChainSelector(chains[0]), protein_selector) group2_selector = AndResidueSelector(ChainSelector(chains[1]), protein_selector) interface_selector = InterGroupInterfaceByVectorSelector() interface_selector.group1_selector(group1_selector) interface_selector.group2_selector(group2_selector) group1_interface_selector = AndResidueSelector(interface_selector, group1_selector) group2_interface_selector = AndResidueSelector(interface_selector, group2_selector) group1_interface_vector = group1_interface_selector.apply(pose) group2_interface_vector = group2_interface_selector.apply(pose) return group1_interface_vector, group2_interface_vector
def select_by_cb_vector(pose): # The Cα-Cβ vector will be <0,0,0> for everything, because the DNA doesn't # have Cα. See `core::select::util::cbeta_vector()`. This means that # nothing will be selected on the basis of angle. A residue would be # selected based on angle if the dot product between Cα1-Cβ1 and Cβ1-Cβ2 is # greater than a threshold (0.25 by default), but the product will always # be 0 if one of the operands is a null vector. # To be included based on distance, the rules are different for protein and # DNA residues. For protein, a sidechain atom needs to be within # `nearby_atom_cut` of any atom in the other group. For DNA, C1' (the # sugar carbon supporting the base, defined as the "neighbor" atom, see # database/chemical/...) needs to be within `nearby_atom_cut` of any atom # in the other group. So DNA is a little more restrictive, because it only # counts distances from one atom, not all atoms. protein_sele = ResiduePropertySelector(core.chemical.PROTEIN) dna_sele = ResiduePropertySelector(core.chemical.DNA) interface_sele = InterGroupInterfaceByVectorSelector(protein_sele, dna_sele) protein_interface_sele = AndResidueSelector(interface_sele, protein_sele) return protein_interface_sele.apply(pose)
def create_enzyme_design_task_factory(active_site_positions: list, neighborhood: float = 0, \ cystine: bool = True, noncanonical_amino_acids: list = list()): task_factory = TaskFactory() if len(noncanonical_amino_acids) > 0: ncaa_palette = CustomBaseTypePackerPalette() for ncaa in noncanonical_amino_acids: ncaa_palette.add_type(ncaa) task_factory.set_packer_palette(ncaa_palette) task_factory.push_back(IncludeCurrent()) # Mutatable enzyme_core_selector = ResidueIndexSelector(','.join( str(active_site_position) for active_site_position in active_site_positions)) interface_selector = InterGroupInterfaceByVectorSelector() interface_selector.group1_selector(enzyme_core_selector) interface_selector.group2_selector( NotResidueSelector(enzyme_core_selector)) designable_selector = AndResidueSelector( interface_selector, NotResidueSelector(enzyme_core_selector)) if not cystine: restriction = RestrictAbsentCanonicalAASRLT() restriction.aas_to_keep('AGILPVFWYDERHKSTMNQ') # AGILPVFWYDERHKSTCMNQ task_factory.push_back( OperateOnResidueSubset(restriction, designable_selector)) # Repack repack = RestrictToRepackingRLT() if neighborhood > 0: repacking_wo_enzyme_core_selector = NeighborhoodResidueSelector() repacking_wo_enzyme_core_selector.set_focus_selector( interface_selector) repacking_wo_enzyme_core_selector.set_distance(neighborhood) repacking_wo_enzyme_core_selector.set_include_focus_in_subset(False) repacking_selector = OrResidueSelector( repacking_wo_enzyme_core_selector, enzyme_core_selector) task_factory.push_back( OperateOnResidueSubset(repack, repacking_selector)) prevent = PreventRepackingRLT() task_factory.push_back( OperateOnResidueSubset( prevent, OrResidueSelector(designable_selector, repacking_selector), True)) else: task_factory.push_back( OperateOnResidueSubset(repack, designable_selector, True)) return task_factory
def packable_residues_selector(peptide_selection, mutable_selection, catalytic_selection): """ Selects the shell of neighbor residues to repack. Packable set should not include the mutable set, since the action is RestrictToRepacking. """ # Making negative selections for mutable and catalytic not_mutable = NotResidueSelector(mutable_selection) not_catalytic = NotResidueSelector(catalytic_selection) # Selecting residues near mutable shell near_mutable = InterGroupInterfaceByVectorSelector() near_mutable.group1_selector(not_mutable) near_mutable.group2_selector(mutable_selection) near_mutable.nearby_atom_cut(8) near_mutable.vector_dist_cut(10) # Selecting residues near the peptide, with wider range for BB mobility near_pep = InterGroupInterfaceByVectorSelector() near_pep.group1_selector(not_mutable) near_pep.group2_selector(peptide_selection) near_pep.nearby_atom_cut(10) near_pep.vector_dist_cut(12) # Combining selections for peptide and near peptide and near mutable inclusive_packable = selector_union( near_mutable, near_pep, peptide_selection, ChainSelector('B')) ##################Chain B hacky # Setting up exclusion of catalytic and mutable residues exclusive_packable = selector_intersection(inclusive_packable, not_mutable, not_catalytic) return exclusive_packable
def pymol_from_sele(name, pose): bools = globals()[name].apply(pose) resis = set() for i, x in enumerate(bools, 1): if x: resis.add(pose.pdb_info().number(i)) sele = 'resi ' + '+'.join(str(x) for x in resis) if resis else 'none' print(f'select {name}, {sele}') protein_sele = ResiduePropertySelector(core.chemical.PROTEIN) dna_sele = ResiduePropertySelector(core.chemical.DNA) interface_sele = InterGroupInterfaceByVectorSelector(protein_sele, dna_sele) # The Cα-Cβ vector will be <0,0,0> for everything, because the DNA doesn't have # Cα. See `core::select::util::cbeta_vector()`. This means that nothing will # be selected on the basis of angle. A residue would be selected based on # angle if the dot product between Cα1-Cβ1 and Cβ1-Cβ2 is greater than a # threshold (0.25 by default), but the product will always be 0 if one of the # operands is a null vector. #interface_sele.vector_dist_cut(0.0) #interface_sele.vector_angle_cut(0.0) #interface_sele.nearby_atom_cut(100.0) #interface_sele.cb_dist_cut(100.0) # To be included based on distance, the rules are different for protein and DNA # residues. For protein, a sidechain atom needs to be within `nearby_atom_cut`
def packable_residues_selector(mutable_selector): """ Selects the shell of neighbor residues to repack Presently hard coded for HCV protease. """ # Selecting regions mutable = mutable_selector not_mutable = NotResidueSelector(mutable_selector) catalytic = ResidueIndexSelector('72,96,154') peptide = ChainSelector('B') pep_not_mutable = AndResidueSelector() pep_not_mutable.add_residue_selector(peptide) pep_not_mutable.add_residue_selector(not_mutable) # Selecting residues near mutable shell near_mutable = InterGroupInterfaceByVectorSelector() near_mutable.group1_selector(not_mutable) near_mutable.group2_selector(mutable) near_mutable.nearby_atom_cut(4) near_mutable.vector_dist_cut(4) # Selecting residues near the peptide near_pep = InterGroupInterfaceByVectorSelector() near_pep.group1_selector(not_mutable) # Protease near_pep.group2_selector(peptide) # Peptide recognition region near_pep.nearby_atom_cut(10) near_pep.vector_dist_cut(12) # Combining selections for near peptide and near mutable residues wide_set = OrResidueSelector() wide_set.add_residue_selector(near_mutable) wide_set.add_residue_selector(near_pep) # Setting up exclusion of catalytic and mutable residues limit_selection = AndResidueSelector() limit_selection.add_residue_selector(NotResidueSelector(catalytic)) limit_selection.add_residue_selector(wide_set) limit_selection.add_residue_selector(not_mutable) # Add back in the peptide expand_selection = OrResidueSelector() expand_selection.add_residue_selector(limit_selection) expand_selection.add_residue_selector(pep_not_mutable) return expand_selection
#'-relax:constrain_relax_to_start_coords on' '-relax:ramp_constraints off', #'-out:levels core.pack.rotamer_set.RotamerSet_:400', #'-out:levels core.pack.rotamer_set.RotamerSet_.extra_rotamers:400', ] pyrosetta.init(' '.join(flags)) pose = pose_from_pdb('1aay.pdb') sfxn = core.scoring.ScoreFunctionFactory.create_score_function('ref2015') protein_sele = ResiduePropertySelector(core.chemical.PROTEIN) dna_sele = ResiduePropertySelector(core.chemical.DNA) interface_sele = InterGroupInterfaceByVectorSelector(protein_sele, dna_sele) protein_interface_sele = AndResidueSelector(interface_sele, protein_sele) ex = core.pack.task.operation.ExtraRotamersGenericRLT() ex.ex1(True) ex.ex2(True) ex.extrachi_cutoff(1) tf = core.pack.task.TaskFactory() tf.push_back(core.pack.task.operation.RestrictToRepacking()) tf.push_back( core.pack.task.operation.OperateOnResidueSubset(ex, protein_interface_sele)) task = tf.create_task_and_apply_taskoperations(pose) rotsets = core.pack.rotamer_set.RotamerSetsFactory.create_rotamer_sets(pose)
def main(args): if args.ligand_type == 'ligand': init_args = ' '.join(['-extra_res_fa', args.ligand_name]) lig_name = args.ligand_name.split('/')[-1].strip('.params') else: init_args = '' pr.init(init_args) sf = pr.get_fa_scorefxn() sf.add_weights_from_file('ref2015') pose = pr.pose_from_pdb(args.input_pdb) sf(pose) print_notice("Scaffold protein Loaded Successfully!") print_notice("Scaffold protein has" + str(pose.total_residue()) + "residues.") if args.symmetric_file: sfsm = SetupForSymmetryMover(args.symmetric_file) sfsm.apply(pose) #Importing list of residues if the ligand is a protein if args.ligand_type == 'protein': ligres = ResidueIndexSelector(args.residue_set) #Targeting the ligand if the ligand isn't protein elif args.ligand_type == 'ligand': ligres = ResidueNameSelector() ligres.set_residue_name3(lig_name) print_notice("Ligand found at resnum: " + \ str(get_residues_from_subset(ligres.apply(pose))) ) #Setting the proteins not in the ligand not_ligand = NotResidueSelector() not_ligand.set_residue_selector(ligres) #Setting the protein considered part of the ligand ligand_distant_contacts = InterGroupInterfaceByVectorSelector() ligand_distant_contacts.group1_selector(ligres) ligand_distant_contacts.group2_selector(not_ligand) ligand_distant_contacts.cb_dist_cut(2.5 * float(args.radius)) ligand_distant_contacts.nearby_atom_cut(float(args.radius)) #Test set: ClosecontactResidueSelector close_contacts = pr.rosetta.core.select.residue_selector.CloseContactResidueSelector( ) close_contacts.central_residue_group_selector(ligres) close_contacts.threshold(float(args.radius)) all_contacts = OrResidueSelector() all_contacts.add_residue_selector(close_contacts) all_contacts.add_residue_selector(ligand_distant_contacts) non_lig_residues = AndResidueSelector() non_lig_residues.add_residue_selector(all_contacts) non_lig_residues.add_residue_selector(not_ligand) #Collecting the residues from the subset neighbor_residues = get_residues_from_subset(non_lig_residues.apply(pose)) pdb_residues = [] for residue in neighbor_residues: print(pose.pdb_info().pose2pdb(residue)) resid = pose.pdb_info().pose2pdb(residue).split() pdb_residues.append(''.join(resid)) print_notice("Ligand found, neighbor residues are: " + ', '.join([x for x in pdb_residues])) print_notice("Ligand found, total neighbor residues is " + str(len(pdb_residues))) #Removing residues in the REMARKS section remove_set = [] f = open(args.input_pdb, 'r') for line in f.readlines(): if 'REMARK' in line: items = [x for x in line.split(' ') if x != ''] residue_set = [int(items[6]), int(items[11])] for resi in residue_set: if resi not in remove_set: remove_set.append(resi) residue_final_set = [] for resi in pdb_residues: idx = int(resi[0:-1]) if idx not in remove_set: residue_final_set.append(resi) #Final list for the designable residues residue_final_set.append('0') print_notice("Neighbor residues cleaned \n \n Residues are: " +\ ', '.join([x for x in residue_final_set])) if args.out_file: out_name = args.out_file else: out_name = args.input_pdb.strip('.pdb') + '_lig.pos' f = open(out_name, "w") for x in residue_final_set: f.write(x + '\n') f.close print("emd182::Wrote ligand position residues of pdb file " + args.input_pdb + " to filename: " + out_name)