def main(): args = parse_arguments() file_list = [] for item in args.infile: if '*' in item: file_list += list(glob.glob(item)) else: file_list.append(item) if args.snapshots: snapshot_indices = read_snapshot_indices(args.snapshots) assert len(file_list) == 1, ("Should only run 1 file at a time with " "particular snapshots specified!") else: snapshot_indices = None for mae_file in file_list: s = load_structure_reader(mae_file) lig_out = '%d_lig.maegz' rcp_out = '%d_rcp.maegz' if args.lig_fmt: assert re.search(r'.*%d.*\.maegz', args.lig_fmt) lig_out = args.lig_fmt if args.rcp_fmt: assert re.search(r'.*%d.*\.maegz', args.rcp_fmt) rcp_out = args.rcp_fmt rcp_asl = args.rcp_asl lig_asl = args.lig_asl j = 1 for i, lig_st in enumerate(s): if snapshot_indices and i not in snapshot_indices: continue rcp_st = lig_st.copy() lig_trj = lig_out % j rcp_trj = rcp_out % j # Select and delete lig from rcp structure lig_selection = structureutil.evaluate_asl(rcp_st, lig_asl) rcp_st.deleteAtoms(lig_selection) rcp_st.append(rcp_trj) # Select and delete rcp from lig structure rcp_selection = structureutil.evaluate_asl(lig_st, rcp_asl) lig_st.deleteAtoms(rcp_selection) lig_st.append(lig_trj) j += 1
def writeRecStructureFile(self): receptor_file = self.keywords.get('RECEPTOR_FILE') if not receptor_file: msg = "bedam_prep: No receptor file specified in the input file" self.exit(msg) if not os.path.exists(receptor_file): msg = 'File does not exist: %s' % receptor_file self.exit(msg) receptor_asl = self.keywords.get('REST_RECEPTOR_ASL') try: st = structure.StructureReader(receptor_file).next() except: print "Cannot open Maestro structure file %s" % receptor_file sys.exit(-1) atoms = [] if receptor_asl: atoms = structureutil.evaluate_asl(st, receptor_asl) # all atoms free for atom in st.atom: atom.property['i_i_constraint'] = 0 # buffer the ones in ASL for iat in atoms: st.atom[iat].property['i_i_constraint'] = 2 receptor_file_restr = self.jobname + '_rcpt_restr' + '.maegz' st.write(receptor_file_restr) self.receptor_file_restr = receptor_file_restr self.ligand_file_restr = self.ligidxfile
def __init__(self, receptor): self.POLAR_RESIDUES = ["ARG","ASP","GLU","HIS","ASN","GLN","LYS","SER","THR","ARN","ASH","GLH","HID","HIE","LYN"] self.HYDROPHOBIC_RESIDUES =["PHE","LEU","ILE","TYR","TRP","VAL","MET","PRO","CYS","ALA","CYX"] self.AROMATIC_RESIDUES = ["PHE","TYR","TRP","TYO"] self.CHARGED_RESIDUES = ["ARG","ASP","GLU","LYS","HIP","CYT","SRO","TYO","THO"] # Bit positions for each interaction: self.bit_pos = {'CONTACT' : 0, 'BACKBONE' : 1, 'SIDECHAIN' : 2, 'POLAR' : 3, 'HYDROPHOBIC' : 4, 'H_ACCEPTOR' : 5, 'H_DONOR' : 6, 'AROMATIC' : 7, 'CHARGED' : 8} self.active_bits = ['CONTACT', 'BACKBONE', 'SIDECHAIN', 'POLAR', 'HYDROPHOBIC', 'H_ACCEPTOR', 'H_DONOR', 'AROMATIC', 'CHARGED'] self.max_bits_per_residue = 9 self.used_bits_number = len(self.active_bits) self.sifts = {} self.receptor_st = receptor backbone_list = structureutil.evaluate_asl( self.receptor_st, "backbone") self.backbone_set = set(backbone_list) """ structureutil.evaluate_asl Search for substructures matching the ASL (Atom Specification Language) the atom index is returned """ polar_list = structureutil.evaluate_asl( self.receptor_st, "res. " + ', '.join(self.POLAR_RESIDUES )) self.polar_set = set( polar_list ) hydrophobic_list = structureutil.evaluate_asl( self.receptor_st, "res. " + ', '.join(self.HYDROPHOBIC_RESIDUES)) self.hydrophobic_set = set( hydrophobic_list ) aromatic_list = structureutil.evaluate_asl( self.receptor_st, "res. " + ', '.join(self.AROMATIC_RESIDUES)) self.aromatic_set = set(aromatic_list) charged_list = structureutil.evaluate_asl ( self.receptor_st, "res. " + ', '.join(self.CHARGED_RESIDUES)) self.charged_set = set( charged_list )
def find_close_residues(self, ligand, cutoff=4.0): lig_name = ligand.title d_ = defaultdict(list) for atom in ligand.atom: # the distance to original point? lig_dist = self.measure_dist([atom.xyz]) # range should refer to the node level in the red black tree close_atoms = self.distances.find_nodes_in_range(lig_dist - cutoff, lig_dist + cutoff) for close in close_atoms: atom_atom_dist = self.measure_dist([atom.xyz], close.data.coords) if atom_atom_dist <= cutoff: self.update_min_max(close.data.res_num) d_[close.data.atom].append((ligand.title, atom)) # Just take into account the special case, H_DONOR and H_RECEPTOR self.fingerprints.add_sift_chunk_special_case(close.data.atom, atom, ligand.title, atom_atom_dist) max_atom_nums = max([len(atom_list) for atom_list in d_.values()]) # modified definition of interaction # print "max in-range atoms count ",max_atom_nums strong_c = 0 exists_c = 0 for close_atom, lig_names in d_.items(): # print lig_names if len(lig_names) >= 3: # print "mark as strong" self.fingerprints.add_sift_chunk_ordinary( close_atom, lig_names[0][0], "strong" ) # we have only on ligand per complex strong_c += 1 else: # print "mark as exists" self.fingerprints.add_sift_chunk_ordinary(close_atom, lig_names[0][0], "exists") exists_c += 1 print sorted([len(lig_names) for lig_names in d_.values()]) ####### start of environmental descriptors ######## # print "strong count",strong_c ,"exists count",exists_c # addition of surrounding environment POLAR_RESIDUES = [ "ARG", "ASP", "GLU", "HIS", "ASN", "GLN", "LYS", "SER", "THR", "ARN", "ASH", "GLH", "HID", "HIE", "LYN", ] HYDROPHOBIC_RESIDUES = ["PHE", "LEU", "ILE", "TYR", "TRP", "VAL", "MET", "PRO", "CYS", "ALA", "CYX"] AROMATIC_RESIDUES = ["PHE", "TYR", "TRP", "TYO"] CHARGED_RESIDUES = ["ARG", "ASP", "GLU", "LYS", "HIP", "CYT", "SRO", "TYO", "THO"] polar_list = structureutil.evaluate_asl(ligand, "res. " + ", ".join(POLAR_RESIDUES)) polar_set = set(polar_list) hydrophobic_list = structureutil.evaluate_asl(ligand, "res. " + ", ".join(HYDROPHOBIC_RESIDUES)) hydrophobic_set = set(hydrophobic_list) aromatic_list = structureutil.evaluate_asl(ligand, "res. " + ", ".join(AROMATIC_RESIDUES)) aromatic_set = set(aromatic_list) charged_list = structureutil.evaluate_asl(ligand, "res. " + ", ".join(CHARGED_RESIDUES)) charged_set = set(charged_list) # print polar_set, hydrophobic_set ,aromatic_set , charged_set env_d_ = dict() for close_atom, lig_names in d_.items(): for lig_atom in [l[1] for l in lig_names]: lig_atom = int(lig_atom) if close_atom not in env_d_.keys(): env_d_[close_atom] = defaultdict(int) if lig_atom in polar_set: # print "it is polar" env_d_[close_atom]["ENV_POLAR"] += 1 elif lig_atom in aromatic_set: # print "it is aromatic" env_d_[close_atom]["ENV_AROMATIC"] += 1 elif lig_atom in hydrophobic_set: # print "it is h" env_d_[close_atom]["ENV_HYDROPHOBIC"] += 1 elif lig_atom in charged_set: # print "it is c" env_d_[close_atom]["ENV_CHARGED"] += 1 atom_nums = list() for a, fp in env_d_.items(): atom_nums += fp.values() max_atom_nums = max(atom_nums) env_stat = {"p_list": [0], "a_list": [0], "h_list": [0], "c_list": [0]} env_stat["p_list"] += [fp["ENV_POLAR"] for a, fp in env_d_.items() if fp["ENV_POLAR"] != 0] env_stat["a_list"] += [fp["ENV_AROMATIC"] for a, fp in env_d_.items() if fp["ENV_AROMATIC"] != 0] env_stat["h_list"] += [fp["ENV_HYDROPHOBIC"] for a, fp in env_d_.items() if fp["ENV_HYDROPHOBIC"] != 0] env_stat["c_list"] += [fp["ENV_CHARGED"] for a, fp in env_d_.items() if fp["ENV_CHARGED"] != 0] print env_stat print max(env_stat["p_list"]), max(env_stat["a_list"]), max(env_stat["h_list"]), max(env_stat["c_list"]) strong_c = 0 exists_c = 0 for a, fp in env_d_.items(): for t, c in fp.items(): if c >= 3: self.fingerprints.add_sift_chunk_env(a, lig_name, t, "strong") strong_c += 1 else: self.fingerprints.add_sift_chunk_env(a, lig_name, t, "exists") exists_c += 1
def __init__(self, receptor): self.POLAR_RESIDUES = [ "ARG", "ASP", "GLU", "HIS", "ASN", "GLN", "LYS", "SER", "THR", "ARN", "ASH", "GLH", "HID", "HIE", "LYN", ] self.HYDROPHOBIC_RESIDUES = ["PHE", "LEU", "ILE", "TYR", "TRP", "VAL", "MET", "PRO", "CYS", "ALA", "CYX"] self.AROMATIC_RESIDUES = ["PHE", "TYR", "TRP", "TYO"] self.CHARGED_RESIDUES = ["ARG", "ASP", "GLU", "LYS", "HIP", "CYT", "SRO", "TYO", "THO"] # Bit positions for each interaction: self.bit_pos = { "CONTACT": 0, "BACKBONE": 1, "SIDECHAIN": 2, "POLAR": 3, "HYDROPHOBIC": 4, "H_ACCEPTOR": 5, "H_DONOR": 6, "AROMATIC": 7, "CHARGED": 8, "ENV_POLAR": 9, "ENV_HYDROPHOBIC": 10, "ENV_AROMATIC": 11, "ENV_CHARGED": 12, } self.active_bits = [ "CONTACT", "BACKBONE", "SIDECHAIN", "POLAR", "HYDROPHOBIC", "H_ACCEPTOR", "H_DONOR", "AROMATIC", "CHARGED", "ENV_POLAR", "ENV_HYDROPHOBIC", "ENV_AROMATIC", "ENV_CHARGED", ] self.max_bits_per_residue = 13 self.used_bits_number = len(self.active_bits) self.sifts = {} self.receptor_st = receptor backbone_list = structureutil.evaluate_asl(self.receptor_st, "backbone") self.backbone_set = set(backbone_list) """ structureutil.evaluate_asl Search for substructures matching the ASL (Atom Specification Language) the atom index is returned """ polar_list = structureutil.evaluate_asl(self.receptor_st, "res. " + ", ".join(self.POLAR_RESIDUES)) self.polar_set = set(polar_list) hydrophobic_list = structureutil.evaluate_asl(self.receptor_st, "res. " + ", ".join(self.HYDROPHOBIC_RESIDUES)) self.hydrophobic_set = set(hydrophobic_list) aromatic_list = structureutil.evaluate_asl(self.receptor_st, "res. " + ", ".join(self.AROMATIC_RESIDUES)) self.aromatic_set = set(aromatic_list) charged_list = structureutil.evaluate_asl(self.receptor_st, "res. " + ", ".join(self.CHARGED_RESIDUES)) self.charged_set = set(charged_list)
def writeRestraintFile(self): # check that structure files with internal indexes have been generated if self.recidxfile is None or self.ligidxfile is None: msg = "writeRestraintFile: Internal error: structure files not found" self.exit(msg) receptor_asl = self.keywords.get('REST_LIGAND_CMRECASL') if not receptor_asl: msg = "bedam_prep: No ASL specified for receptor site center" self.exit(msg) ligand_asl = self.keywords.get('REST_LIGAND_CMLIGASL') if not ligand_asl: ligand_asl = '( all)' try: st = structure.StructureReader(self.recidxfile).next() except: print "Cannot open Maestro structure file %s" % self.recidxfile sys.exit(-1) nrecatoms = len(st.atom) atoms = structureutil.evaluate_asl(st, receptor_asl) rec_atoms = []; for iat in atoms: rec_atoms.append(st.atom[iat].property['i_i_internal_atom_index']) #computes receptor CM cmrx = cmry = cmrz = 0. for iat in atoms: cmrx += st.atom[iat].x cmry += st.atom[iat].y cmrz += st.atom[iat].z n = len(atoms) cmrx /= float(n) cmry /= float(n) cmrz /= float(n) try: st = structure.StructureReader(self.ligidxfile).next() except: print "Cannot open Maestro structure file %s" % self.ligidxfile sys.exit(-1) nligatoms = len(st.atom) atoms = structureutil.evaluate_asl(st, ligand_asl) lig_atoms = []; for iat in atoms: lig_atoms.append(st.atom[iat].property['i_i_internal_atom_index']-nrecatoms) #computes ligand CM cmlx = cmly = cmlz = 0. for iat in atoms: cmlx += st.atom[iat].x cmly += st.atom[iat].y cmlz += st.atom[iat].z n = len(atoms) cmlx /= float(n) cmly /= float(n) cmlz /= float(n) #computes and reports the distance btw CM's d = sqrt((cmlx - cmrx)*(cmlx - cmrx) + (cmly - cmry)*(cmly - cmry) + (cmlz - cmrz)*(cmlz - cmrz)) print "CM-CM distance = %f" % d self.restraint_file = self.jobname + '_cmrestraint.dat' f = open(self.restraint_file,"w") f.write("Receptor\n") f.write("%d\n" % 1) f.write("%d\n" % len(rec_atoms) ) for i in rec_atoms: f.write("%d\n" % i) f.write("Ligand\n") f.write("%d\n" % 2) f.write("%d\n" % len(lig_atoms) ) for i in lig_atoms: f.write("%d\n" % i) f.close()