def selector_intersection(*selectors): """ Returns the intersection of any set of selectors """ intersect_selection = AndResidueSelector() for s in selectors: intersect_selection.add_residue_selector(s) return intersect_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 create_design_task_factory(designable_res_indexes: list, active_site_positions: list = 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 designable_selector = ResidueIndexSelector(','.join( str(designable_res_index) for designable_res_index in designable_res_indexes)) if not cystine: restriction = RestrictAbsentCanonicalAASRLT() restriction.aas_to_keep('AGILPVFWYDERHKSTMNQ') # AGILPVFWYDERHKSTCMNQ task_factory.push_back( OperateOnResidueSubset(restriction, designable_selector)) # Repack repack = RestrictToRepackingRLT() prevent = PreventRepackingRLT() if neighborhood > 0: if len(active_site_positions) > 0: enzdes_cst_selector = ResidueIndexSelector(','.join( str(enzdes_cst_index) for enzdes_cst_index in active_site_positions)) designable_repacking_selector = NeighborhoodResidueSelector() designable_repacking_selector.set_focus_selector( OrResidueSelector(designable_selector, enzdes_cst_selector)) designable_repacking_selector.set_distance(neighborhood) designable_repacking_selector.set_include_focus_in_subset(True) repacking_selector = AndResidueSelector( designable_repacking_selector, NotResidueSelector(designable_selector)) task_factory.push_back( OperateOnResidueSubset(repack, repacking_selector)) task_factory.push_back( OperateOnResidueSubset(prevent, designable_repacking_selector, True)) else: repacking_selector = NeighborhoodResidueSelector() repacking_selector.set_focus_selector(designable_selector) repacking_selector.set_distance(neighborhood) repacking_selector.set_include_focus_in_subset(False) task_factory.push_back( OperateOnResidueSubset(repack, repacking_selector)) 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 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 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 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 make_task_factory(residue_selectors, confine_design=None): """ Makes a TaskFactory with operations that leave the mutable residues designable, restricts the nearby residues to repacking, and prevents repacking of other residues. Also includes the ability to take in a target residue mutatations text file in the form: res_number allowed_AAs for example: 138 KR All designable residues not listed in the file are restricted to repacking and the listed residues are limited in their design options to those AAs listed. """ design_set = residue_selectors['mutable'] repack_set = residue_selectors['packable'] other_set = residue_selectors['other'] prevent = PreventRepackingRLT() # No repack, no design repack = RestrictToRepackingRLT() # No design tf = TaskFactory() tf.push_back(OperateOnResidueSubset(prevent, other_set)) tf.push_back(OperateOnResidueSubset(repack, repack_set)) # Everything else left designable by default # Restricting design further if confine_design: trms = readfile(confine_design) # Converting lines to a dict limited_set = \ {int(line.split()[0]):line.split()[1] for line in trms} # Converting residues in the dict to a selector res_concatenated = str(limited_set.keys()).strip('[]').replace(' ','') small_des_set = ResidueIndexSelector(res_concatenated) now_only_repack = NotResidueSelector(small_des_set) # Making residue selection excluding residues in the file and # restricting them to repacking no_longer_designable = AndResidueSelector() no_longer_designable.add_residue_selector(design_set) no_longer_designable.add_residue_selector(now_only_repack) tf.push_back(OperateOnResidueSubset(repack, no_longer_designable)) # Limiting design on residues in the file for res, AAs in limited_set.items(): designable_res = ResidueIndexSelector(str(res)) restrict_AAs = RestrictAbsentCanonicalAASRLT() restrict_AAs.aas_to_keep(AAs) tf.push_back(OperateOnResidueSubset(restrict_AAs, designable_res)) return tf
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 check_selector_nonzero_intersections(selectors_list, pose): """ Takes an input list of selectors and a pose, and checks the intersection of the selectors applied to the pose, returning a boolean indicating whether the intersection set is empty, and the intersection set. """ # Make an AndResidueSelector ars = AndResidueSelector() # Add all selectors in the input list for sel in selectors_list: ars_s.add_residue_selector(sel) # Get intersection residues list intersection_list = selector_to_list(pose, ars) # Check whether list is empty is_intersection_empty = len(intersection_list) == 0 return is_intersection_empty, intersection_list
if f.endswith('.params'): params.append(f) if len(params) > 0: init('-extra_res_fa ' + ' '.join(params)) else: init() pose = pose_from_pdb(args.pdb) prefix = args.pdb[args.pdb.rfind('/') + 1:-4] i = prefix.find('_') if i != -1: prefix = args.pdb[:i] if args.chain: # Residues having the same pdb chain id do not necessarily share the same pose chain id. # Convert pdb chain index to pose chain index. chain_selector = AndResidueSelector( ChainSelector(args.chain), ResiduePropertySelector(ResidueProperty.PROTEIN)) chain_vector = chain_selector.apply(pose) chain_begin = None chain_end = None for res_index, res in enumerate(chain_vector): if res: if not chain_begin: chain_begin = res_index + 1 # chain_index = pose.chain(res_index + 1) # break else: if chain_begin: chain_end = res_index break if not chain_end:
'N446E': 'pdz_relaxed_2.pdb_designed_9.pdb' } for des, muts in res_changes.items(): pp = pose_from_pdb('pdz_designs/examples/' + start_pdb[des]) peptide = ChainSelector('B') shell = NeighborhoodResidueSelector() shell.set_focus_selector(peptide) shell.set_include_focus_in_subset(True) shell.set_distance(12) mobile_residues = OrResidueSelector() tf = TaskFactory() tf.push_back(IncludeCurrent()) tf.push_back(ExtraRotamers(0, 1, 1)) tf.push_back(ExtraRotamers(0, 2, 1)) for r, aa in muts.items(): res_selection = ResidueIndexSelector(str(r)) restriction = RestrictAbsentCanonicalAASRLT() restriction.aas_to_keep(aa.upper()) tf.push_back(OperateOnResidueSubset(restriction, res_selection)) mobile_residues.add_residue_selector(res_selection) packable = AndResidueSelector(shell, NotResidueSelector(mobile_residues)) tf.push_back(OperateOnResidueSubset(RestrictToRepackingRLT(), packable)) not_changing = NotResidueSelector(shell) tf.push_back(OperateOnResidueSubset(PreventRepackingRLT(), not_changing)) pt = tf.create_task_and_apply_taskoperations(pose) prm = PackRotamersMover(sf, pt) prm.apply(pp) pp.dump_pdb('pdz_designs/design_models/pdz_' + des + '.pdb') # Run analyze_design_decoys.fix_file() # python relax_new_pdb.py $i -od fibrils_collaboration/pdz_designs/design_models/round_2/ -cst fibrils_collaboration/htra1_pdz.cst -ccw 0 -n 10
def residue_pairs( self, primary_residue_selector=TrueResidueSelector(), secondary_residue_selector=TrueResidueSelector(), neighborhood_distance_maximum=None, sequence_distance_minimum=None, ): """Iterate the permutations of residue pairs from two selections which are within a cartesian and/or outside a sequence distance cutoff. The method uses the PrimarySequenceNeighborhoodSelector and NeighborhoodResidueSelector under the hood. Note that all _permutations_ of residues are yielded, not _combinations_. If you prefer combinations simply check `if residue_pair[0].sequence_position() > residue_pair[1].sequence_position():`. primary_residue_selector - ResidueSelector secondary_residue_selector - ResidueSelector neighborhood_distance - float sequence_distance - int return - iterator(tuple(Residue, Residue)) """ primary_residue_selection = primary_residue_selector.apply(self) primary_residue_indices = get_residues_from_subset(primary_residue_selection) for primary_residue_index in primary_residue_indices: temp_secondary_residue_selector = secondary_residue_selector primary_residue_index_selector = ResidueIndexSelector(primary_residue_index) temp_secondary_residue_selector = AndResidueSelector( temp_secondary_residue_selector, NotResidueSelector(primary_residue_index_selector), ) if ( neighborhood_distance_maximum ): # Select residues within cartesian neighborhood distance neighborhood_residue_selector = NeighborhoodResidueSelector( primary_residue_index_selector, neighborhood_distance_maximum, False ) temp_secondary_residue_selector = AndResidueSelector( temp_secondary_residue_selector, neighborhood_residue_selector ) if ( sequence_distance_minimum ): # Select residues outside sequence neighborhood distance sequence_residue_selector = PrimarySequenceNeighborhoodSelector( sequence_distance_minimum, sequence_distance_minimum, primary_residue_index_selector, ) temp_secondary_residue_selector = AndResidueSelector( temp_secondary_residue_selector, NotResidueSelector(sequence_residue_selector), ) secondary_residue_selection = temp_secondary_residue_selector.apply(self) secondary_residue_indices = get_residues_from_subset( secondary_residue_selection ) for secondary_residue_index in secondary_residue_indices: yield tuple( [ self.residues[primary_residue_index], self.residues[secondary_residue_index], ] )
def create_relax_task_factory(point_mutations: list = list(), active_site_positions: list = list(), neighborhood: float = 0): task_factory = TaskFactory() task_factory.push_back(IncludeCurrent()) repack = RestrictToRepackingRLT() prevent = PreventRepackingRLT() if len(point_mutations) > 0: # Mutate mutated_selector = OrResidueSelector() for point_mutation in point_mutations: mutation_info = point_mutation.split(',') restriction = RestrictAbsentCanonicalAASRLT() restriction.aas_to_keep(mutation_info[1]) point_mutation_selector = ResidueIndexSelector(mutation_info[0]) task_factory.push_back( OperateOnResidueSubset(restriction, point_mutation_selector)) mutated_selector.add_residue_selector(point_mutation_selector) # Repack and static if neighborhood > 0: if len(active_site_positions) > 0: # Repack enzyme_core_selector = ResidueIndexSelector(','.join( str(active_site_position) for active_site_position in active_site_positions)) designable_repacking_selector = NeighborhoodResidueSelector() designable_repacking_selector.set_focus_selector( OrResidueSelector(mutated_selector, enzyme_core_selector)) designable_repacking_selector.set_distance(neighborhood) designable_repacking_selector.set_include_focus_in_subset(True) repacking_selector = AndResidueSelector( designable_repacking_selector, NotResidueSelector(mutated_selector)) task_factory.push_back( OperateOnResidueSubset(repack, repacking_selector)) # Static task_factory.push_back( OperateOnResidueSubset(prevent, designable_repacking_selector, True)) else: # Repack repacking_selector = NeighborhoodResidueSelector() repacking_selector.set_focus_selector(mutated_selector) repacking_selector.set_distance(args.neighborhood) repacking_selector.set_include_focus_in_subset(False) task_factory.push_back( OperateOnResidueSubset(repack, repacking_selector)) # Static mutated_and_repacking_selector = OrResidueSelector( mutated_selector, repacking_selector) task_factory.push_back( OperateOnResidueSubset(prevent, mutated_and_repacking_selector, True)) else: # Repack task_factory.push_back( OperateOnResidueSubset(repack, mutated_selector, True)) else: if neighborhood > 0: if len(active_site_positions) > 0: # Repack enzyme_core_selector = ResidueIndexSelector(','.join( str(active_site_position) for active_site_position in active_site_positions)) repacking_selector = NeighborhoodResidueSelector() repacking_selector.set_focus_selector(enzyme_core_selector) repacking_selector.set_distance(neighborhood) repacking_selector.set_include_focus_in_subset(True) task_factory.push_back( OperateOnResidueSubset(repack, repacking_selector)) # Static task_factory.push_back( OperateOnResidueSubset(prevent, repacking_selector, True)) else: # Static task_factory.push_back(PreventRepacking()) else: # Repack task_factory.push_back(RestrictToRepacking()) return task_factory
from pyrosetta.rosetta.core.select.residue_selector import AndResidueSelector from pyrosetta.rosetta.core.select.residue_selector import ChainSelector from pyrosetta.rosetta.core.select.residue_selector import SecondaryStructureSelector from pyrosetta.rosetta.protocols.symmetry import DetectSymmetry from pyrosetta.rosetta.protocols.symmetry import SetupForSymmetryMover from stapler import NativeDisulfideStapler # Preset ResidueSelectors default_residue_selectors = [TrueResidueSelector(), TrueResidueSelector()] interface_residue_selectors = [ChainSelector('A'), ChainSelector('B')] interface_or_internal_residue_selectors = [ChainSelector('A'), ChainSelector('A,B')] only_binder_residue_selectors = [ChainSelector('B'), ChainSelector('B')] not_on_loops = [SecondaryStructureSelector('HE'), SecondaryStructureSelector('HE')] not_on_loops_across_interface = [AndResidueSelector(SecondaryStructureSelector('HE'),ChainSelector('A')), AndResidueSelector(SecondaryStructureSelector('HE'),ChainSelector('B'))] # Initialize the native disulfide stapler with defaults. native_disulfide_stapler = NativeDisulfideStapler( residue_selectors=default_residue_selectors, minimum_sequence_distance=4 ) for pdb in glob.glob('_inputs/*.pdb'): pdb_filename = os.path.splitext(os.path.basename(pdb))[0] pose = pyrosetta.pose_from_file(pdb) # Preset Movers for Symmetry # DetectSymmetry().apply(pose)
# 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` # 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_interface_sele = AndResidueSelector(interface_sele, protein_sele) print('interface_sele.vector_dist_cut =', interface_sele.vector_dist_cut()) print('interface_sele.vector_angle_cut =', interface_sele.vector_angle_cut()) print('interface_sele.nearby_atom_cut =', interface_sele.nearby_atom_cut()) print('interface_sele.cb_dist_cut =', interface_sele.cb_dist_cut()) pymol_from_sele('protein_sele', pose) pymol_from_sele('dna_sele', pose) pymol_from_sele('interface_sele', pose) pymol_from_sele('protein_interface_sele', pose) raise SystemExit #n_close = 0 #n_contact = 0
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
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 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)