def save_merged_ligand_protein(self, raw_protein_file, raw_ligand_file): """ Merge structures from files and save to save directory :param raw_ligand_file: absolute paths :return: """ prot_st = next(StructureReader(raw_protein_file)) alpha = 'ABCDEFGHIJKMNOPQRST' alpha_count = 0 for c in prot_st.chain: if c.name.strip() == '': continue c.name = alpha[alpha_count] alpha_count += 1 if raw_ligand_file != '': lig_st = next(StructureReader(raw_ligand_file)) # standardize chain naming for c in lig_st.chain: c.name = 'L' merged_st = lig_st.merge(prot_st) else: merged_st = prot_st st_wr = StructureWriter(self.path + self.raw_complex) st_wr.append(merged_st) st_wr.close()
def get_residues_from_radius(radius, ref): asl = 'fillres ((within %i ligand ) and not (res.ptype "T3P"))' % (int(float(radius))) st=StructureReader(ref).next() atoms=evaluate_asl(st, asl) if len(atoms)==0: print "NO LIGAND IN REFERENCE FILE" print "no ligand in reference file" sys.exit() pocket=st.extract(atoms) resnames=[i.pdbres for i in pocket.residue] resnums=[i.resnum for i in pocket.residue] chains=[i.chain for i in pocket.residue] data=dict() for chain in set(chains): for (n,c) in zip(resnums, chains): if c not in data.keys(): data[c]=[] if str(n) not in data[c]: data[c].append(str(n)) selection=[] for chain in data.keys(): selection.append(','.join(data[chain]) + '.%s' % chain) if len(selection)==1: selection=[selection,] return selection
def write_grid_in_file(self, mode, grid_ligand='', xyz=False, receptor_file=''): if mode == 'other_ligand': st_2 = next(StructureReader(grid_ligand)) c2 = get_centroid(st_2) x, y, z = c2[:3] elif mode == 'xyz': x, y, z = xyz else: st_2 = next(StructureReader(self.path + self.split_ligand)) c2 = get_centroid(st_2) x, y, z = c2[:3] if receptor_file == '': use_file = self.split_protein else: use_file = receptor_file with open(self.path + self.grid_in, 'w') as f: f.write('GRID_CENTER {},{},{}\n'.format(x, y, z)) f.write('GRIDFILE {}\n'.format(self.grid_file)) f.write('INNERBOX 15,15,15\n') f.write('OUTERBOX 30,30,30\n') f.write('RECEP_FILE {}\n'.format(use_file))
def get_residues_from_radius(radius, ref): asl = 'fillres ((within %i ligand ) and not (res.ptype "T3P"))' % (int( float(radius))) st = StructureReader(ref).next() atoms = evaluate_asl(st, asl) if len(atoms) == 0: print "NO LIGAND IN REFERENCE FILE" print "no ligand in reference file" sys.exit() pocket = st.extract(atoms) resnames = [i.pdbres for i in pocket.residue] resnums = [i.resnum for i in pocket.residue] chains = [i.chain for i in pocket.residue] data = dict() for chain in set(chains): for (n, c) in zip(resnums, chains): if c not in data.keys(): data[c] = [] if str(n) not in data[c]: data[c].append(str(n)) selection = [] for chain in data.keys(): selection.append(','.join(data[chain]) + '.%s' % chain) if len(selection) == 1: selection = [ selection, ] return selection
def extract_prot_lig(self, structure_set_info): ''' Setup and start running a set of docking task structure_set_info: (list of dicts) [{'folder', 'pdb', 'prot':['A','B'], 'lig':'L'}] :return: (None) for structure in structure_set_info: with StructureReader(input_pdb) as st: st = list(st)[0] ''' print(structure_set_info) for task in structure_set_info: base = task['folder'] + '/' + task['name'] if task['method'] == 'by_chain': #extract specific chains with StructureReader(base + '.pdb') as st: st = list(st)[0] st_prot = st.chain[task['P']].extractStructure( copy_props=True) st_prot.write(base + '_prot.mae') st_lig = st.chain[task['L']].extractStructure( copy_props=True) st_lig.write(base + '_lig.mae') if task['method'] == 'by_res': #extract specific chains with StructureReader(base + '.pdb') as st: st = list(st)[0] lig = [ a.index for a in st.atom if a.getResidue().pdbres == task['L'] ] print(lig) st_lig = st.extract(lig) st_lig.write(base + '_lig.mae') st_prot = st.extract([ a.index for a in st.atom if a.getResidue().pdbres != task['L'] ]) st_prot.write(base + '_prot.mae') if task['method'] == 'from_PDBBind': print(task['method']) name_lower = task['name'].lower() with StructureReader(task['folder'] + '/' + name_lower + '_protein.pdb') as st: st = list(st)[0] st.write(base + '_prot.mae') with StructureReader(task['folder'] + '/' + name_lower + '_ligand.mol2') as st: st = list(st)[0] st.write(base + '_lig.mae') return False
def create_feature_vector(protein, ligand, pickle_file, combind_root): ending_1 = '{}/structures/aligned_files/{}/{}_out.mae'.format( protein, ligand, ligand) s = list(StructureReader(combind_root + ending_1))[0] rot_s = list(StructureReader(combind_root + '/' + ending_1))[0] residues = get_all_res(s, rot_s) print(residues) outfile = open(pickle_file, 'wb') pickle.dump(residues, outfile) outfile.close()
def check_selection_boolean(ref, target): st=StructureReader(ref).next() atoms=evaluate_asl(st, 'all') sub=st.extract(atoms) resnames=[i.pdbres.rstrip() for i in sub.residue] if target in resnames: verdict=True else: verdict=False return verdict
def check_selection_boolean(ref, target): st = StructureReader(ref).next() atoms = evaluate_asl(st, 'all') sub = st.extract(atoms) resnames = [i.pdbres.rstrip() for i in sub.residue] if target in resnames: verdict = True else: verdict = False return verdict
def load_pdb_struct(path,residue_cls = BaseResidue): st = StructureReader(path).next() st = mystructure(st) if residue_cls is not None: residues = map(residue_cls,st.residue) #use custom Residue class st.residues = residues st.src = path return st
def compute_protein_mcss(protein, ligands, save_folder): init_file = '{}/{}_mcss.csv'.format(save_folder, protein) for i in range(len(ligands)): for j in range(i + 1, len(ligands)): l1, l2 = ligands[i], ligands[j] l1_path = '/scratch/PI/rondror/combind/bpp_data/MAPK14/ligands/prepared_ligands/{}_lig/{}_lig.mae'.format( l1, l1) l2_path = '/scratch/PI/rondror/combind/bpp_data/MAPK14/ligands/prepared_ligands/{}_lig/{}_lig.mae'.format( l2, l2) mcss_types_file = 'mcss_type_file.typ' mcss = MCSS(l1, l2) with StructureReader(l1_path) as ligand1, StructureReader( l2_path) as ligand2: ligands = {l1: next(ligand1), l2: next(ligand2)} mcss.compute_mcss(ligands, init_file, mcss_types_file)
def generate_tree(maefile, origin, charge): """ A helper function to generate tree structure from a given maefile and origin :type maefile: str :param maefile: name of the maefile, endwith .mae :type origin: int :param origin: atom of interest :type charge: bool :param charge: use ESP charge for atomic descriptor return tree structure """ print(f'Processing {maefile}') st = next(StructureReader(maefile)) sorted_atoms = sort_atom_by_atomic(st) print(f'Using atom {origin} ({st.atom[origin].element}) as origin.\n') if charge: try: root = Node(None, origin, st.atom[origin].element, st.atom[origin].property['r_j_ESP_Charges'], None, set()) except: sys.exit( 'Warning: You need to have ESP charge in the maefile in order to run charge option!!!' ) else: root = Node(None, origin, st.atom[origin].element, 0, None, set()) get_stereomatic_desc(st, root, sorted_atoms, charge) return root
def main(): args = parse_args() print("args", args) if args.implementation == TORCHANI: from torchani_calculator import torchani_calculator calculator = torchani_calculator(args.network_type, args.numb_networks) elif args.implementation == AES_ANI: from ani_ase import ani_ase_calculator calculator = ani_ase_calculator(args.network_type) elif args.implementation == KHAN: from khan_calculator import khan_calculator calculator = khan_calculator(args.network_type, args.khan_network, args.numb_networks) strs = list(StructureReader(args.mae_file)) cvgd = optimize_structures(strs, calculator.committee, maxit=500, thresh=0.01) rd = rawdataset_from_st(strs) energy_data = calculator.committee.compute_data(rd) for st, data in zip(strs, energy_data): st.property["r_j_ANI_ENERGY"] = data.energy st.property["r_j_ANI_RHO"] = data.rho base, ext = os.path.splitext(args.mae_file) outfile = base + "_optimized" + ext print("final structure written to file: %s" % outfile) with StructureWriter(outfile) as writer: writer.extend(strs)
def molecule_to_schrodinger_struct(molecule: Molecule): """ Convert a pymatgen Molecule object to a Schrodinger Structure object Args: molecule (pymatgen.core.structure.Molecule): Molecule to be converted Returns: struct: schrodinger.structure.Structure object """ # First need to convert molecule to file to use StructureReader file_suffix = random.randint(1, 100000000) molecule.to('sdf', "temp_conversion{}.sdf".format(file_suffix)) reader = StructureReader("temp_conversion{}.sdf".format(file_suffix)) # Assume only one structure (should be the case for a single SDF file) struct = [r for r in reader][0] for atom in struct.atom: atom.formal_charge = 0 struct.atom[1].formal_charge = molecule.charge Path("temp_conversion{}.sdf".format(file_suffix)) return struct
def aggregate_structures(data_path, save_location, scores_version): protein = 'MAPK14' print(protein) #try to load the score file scores_file = "{}/{}/scores/{}/pdb.sc".format(data_path, protein, scores_version) if os.path.isfile(scores_file): ligand_folder = '{}/{}/structures/aligned_files'.format( data_path, protein) ligands = os.listdir(ligand_folder) # write one mae files for all poses with StructureWriter('{}/all_{}_pv.mae'.format(save_location, protein)) as all: #iterate over each scored ligand for i, ligand in enumerate(ligands): pose_file = "{}/{}/structures/aligned_files/{}/{}_out.mae".format( data_path, protein, ligand, ligand) #load the structure file containing docking results pv = list(StructureReader(pose_file)) print(pv) #add the protein structure but only for the first file all.append(pv[0])
def compute_protein_mcss(ligands, pair_path): init_file = '{}/{}-to-{}_mcss.csv'.format(pair_path, ligands[0], ligands[1]) for i in range(len(ligands)): for j in range(i + 1, len(ligands)): l1, l2 = ligands[i], ligands[j] l1_path = '{}/ligand_poses/{}_lig0.mae'.format(pair_path, l1) new_l1_path = create_mcss_file(l1_path, l1, pair_path) l2_path = '{}/{}_lig.mae'.format(pair_path, l2) new_l2_path = create_mcss_file(l2_path, l2, pair_path) mcss_types_file = 'mcss_type_file.typ' mcss = MCSS(l1, l2) with StructureReader(new_l1_path) as ligand1, StructureReader( new_l2_path) as ligand2: ligands = {l1: next(ligand1), l2: next(ligand2)} mcss.compute_mcss(ligands, init_file, mcss_types_file) os.system('rm {} {}'.format(new_l1_path, new_l2_path))
def _show_schrodinger_file(path, **kwargs): from schrodinger.structure import StructureReader view = NGLWidget() cts = list(StructureReader(path)) for ct in cts: view.add_component(SchrodingerStructure(ct), **kwargs) return view
def load_poses(self, maxposes=10): poses = [] for i, st in enumerate(StructureReader(self.folder+'/'+self.pose_viewer_file_name)): if i > maxposes: break if i == 0: prot_st = st continue poses.append(st) return prot_st, poses
def get_sequence_from_str(file): s = list(StructureReader(file))[0] str = '' for m in list(s.molecule): if len(m.residue) != 1: for r in list(m.residue): atom = list(r.atom)[0] if (atom.chain == "A"): # to fix for MAPK14: 3GCU str += atom.pdbcode return str
def get_sequence_from_str(file, chains, protein): s = list(StructureReader(file))[0] str = '' for m in list(s.molecule): if len(m.residue) != 1: for r in list(m.residue): atom = list(r.atom)[0] if atom.chain == chains[protein]: str += atom.pdbcode return str
def main(): coms = {} with open(prot_file) as fp: for line in tqdm(fp, desc='protein file'): if line[0] == '#': continue protein, target, start = line.strip().split() if protein not in coms: coms[protein] = {} protein_folder = os.path.join(data_root, protein + '/structures/aligned') if start not in coms[protein]: file = os.path.join(protein_folder, start + '_prot.mae') s = list(StructureReader(file))[0] coms[protein][start] = analyze.center_of_mass(s) file = os.path.join(protein_folder, start + '_prot.mae') s = list(StructureReader(file))[0] coms[protein][start] = analyze.center_of_mass(s) with open('com_after_aligned.pkl', 'wb') as f: pickle.dump(coms, f)
def docking(grid): ligands = os.listdir(grid) similarities = [] lgr = logger() cfg = CanvasFingerprintGenerator(lgr, 'Radial') cfs = CanvasFingerprintSimilarity(lgr) cfs.setMetric('Tanimoto') for struc_ligand in ligands: for ligand in ligands: prepped_ligand_file = '/scratch/PI/rondror/combind/bpp_data/MAPK14/ligands/prepared_ligands/{}_lig/{}_lig.mae'.format( ligand, ligand) prepped_struc_ligand_file = '/scratch/PI/rondror/combind/bpp_data/MAPK14/ligands/prepared_ligands/{}_lig/{}_lig.mae'.format( struc_ligand, struc_ligand) lig = cfg.generate(next(StructureReader(prepped_ligand_file))) struc_lig = cfg.generate( next(StructureReader(prepped_struc_ligand_file))) similarities.append(cfs.calculateSimilarity(lig, struc_lig)) outfile = open('/home/users/sidhikab/MAPK14_similarities', 'wb') pickle.dump(similarities, outfile) outfile.close()
def find_chain(protein, chains, ligand): protein_folder = os.path.join(data_root, protein + '/structures/aligned') primary_file = os.path.join(protein_folder, ligand + '_prot.mae') s = list(StructureReader(primary_file))[0] chain_list = [] for m in list(s.molecule): for r in list(m.residue): atom = list(r.atom)[0] if atom.chain not in chain_list: chain_list.append(atom.chain) if protein not in chains: chains[protein] = chain_list else: chains[protein] = set.intersection(set(chains[protein]), set(chain_list))
def main(): coms = {} with open(prot_file) as fp: for line in tqdm(fp, desc='protein file'): if line[0] == '#': continue protein, target, start = line.strip().split() if protein not in coms: coms[protein] = {} if start not in coms[protein]: start_receptor_file = os.path.join( data_root, '{}/structures/aligned/{}_prot.mae'.format(protein, start)) start_ligand_file = os.path.join( data_root, '{}/structures/aligned/{}_lig.mae'.format(protein, start)) start_struct = list(StructureReader(start_receptor_file))[0] start_lig = list(StructureReader(start_ligand_file))[0] # print(protein, start) coms[protein][start] = get_pocket_res(start_struct, start_lig) if target not in coms[protein]: target_receptor_file = os.path.join( data_root, '{}/structures/aligned/{}_prot.mae'.format( protein, target)) target_ligand_file = os.path.join( data_root, '{}/structures/aligned/{}_lig.mae'.format(protein, target)) target_struct = list(StructureReader(target_receptor_file))[0] target_lig = list(StructureReader(target_ligand_file))[0] # print(protein, target) get_pocket_res(target_struct, target_lig) with open('pocket_com.pkl', 'wb') as f: pickle.dump(coms, f)
def main(): maefile = sys.argv[1] origin = int(sys.argv[2]) print(f'Processing {maefile}') st = next(StructureReader(maefile)) print(f'Using atom {origin} ({st.atom[origin].element}) as origin.\n') # Index of atom origin of stereomatic network sd = get_stereomatic_desc(st, origin, set([origin])) print(sd) with open(maefile.replace('.mae', '.json'), 'w') as fh: json.dump(sd, fh, indent=4)
def _set_ligand_sizes(self, structure_file): try: refs = [st for st in StructureReader(structure_file)] except: print('Unable to read MCSS structure file for', self.l1, self.l2) return None if len(refs) != 2: print('Wrong number of structures', self.l1, self.l2) return None ref1, ref2 = refs n_l1_atoms = len([a for a in ref1.atom if a.element != 'H']) n_l2_atoms = len([a for a in ref2.atom if a.element != 'H']) self.n_l1_atoms = n_l1_atoms self.n_l2_atoms = n_l2_atoms
def run_group(grouped_files, raw_root, index, clash_dir): """ checks mean distance of displacement for decoys for each protein, target, start group :param grouped_files: (list) list of protein, target, start groups :param raw_root: (string) directory where raw data will be placed :param index: (int) group number :param dist_dir: (string) directiory to place distances :param max_poses: (int) maximum number of glide poses considered :param max_decoys: (int) maximum number of decoys created per glide pose :return: """ clash_dict = {} for protein, target, start in grouped_files[index]: protein_path = os.path.join(raw_root, protein) pair_path = os.path.join(protein_path, '{}-to-{}'.format(target, start)) pose_path = os.path.join(pair_path, 'ligand_poses') struct_path = os.path.join(pair_path, '{}_prot.mae'.format(start)) lig_path = os.path.join(pose_path, '{}_lig0.mae'.format(target)) s1 = list(StructureReader(struct_path))[0] lig = list(StructureReader(lig_path))[0] clash_dict[(protein, target, start)] = steric_clash.clash_volume(s1, struc2=lig) outfile = open(os.path.join(clash_dir, '{}.pkl'.format(index)), 'wb') pickle.dump(clash_dict, outfile)
def file_to_schrodinger_structure(filename: Union[str, Path]): """ Convert a file (sdf, pdb, sd, mol2, maestro, or maestro_text) to a Schrodinger Structure object. Args: filename (str): Name of the file Returns: structures (list of schrodinger.structure.Structure objects) """ if isinstance(filename, Path): fn = filename.as_posix() else: fn = filename reader = StructureReader(fn) structures = [s for s in reader] return structures
def run_group(grouped_files, raw_root, index): for protein, target, start in grouped_files[index]: pair = '{}-to-{}'.format(target, start) protein_path = os.path.join(raw_root, protein) pair_path = os.path.join(protein_path, pair) pose_path = os.path.join(pair_path, 'ligand_poses') # comput mcss compute_protein_mcss([target, start], pair_path) # combine ligands with StructureWriter('{}/{}_merge_pv.mae'.format(pair_path, pair)) as all_file: for file in os.listdir(pose_path): if file[-3:] == 'mae': pv = list(StructureReader(os.path.join(pose_path, file))) all_file.append(pv[0]) # zip file os.system('gzip -f {}/{}_merge_pv.mae'.format(pair_path, pair, pair_path, pair))
def split(self): #look for the opt_complex, if it doesn't exist, just use the prepped complex usefile = '' if (os.path.isfile(self.path + self.align_file)): usefile = self.path + self.align_file else: usefile = self.path + self.prepped_complex st = next(StructureReader(usefile)) prot_st = st.extract([a.index for a in st.atom if a.chain != 'L']) prot_st.title = '{}_prot'.format(self.name) lig_st = st.extract([a.index for a in st.atom if a.chain == 'L']) lig_st.title = '{}_lig'.format(self.name) prot_wr = StructureWriter(self.path + self.split_protein) prot_wr.append(prot_st) prot_wr.close() lig_wr = StructureWriter(self.path + self.split_ligand) lig_wr.append(lig_st) lig_wr.close()
def main(): args = parse_args() print("args", args) if args.implementation == TORCHANI: from torchani_calculator import torchani_calculator calculator = torchani_calculator(args.network_type, args.numb_networks) elif args.implementation == AES_ANI: from ani_ase import ani_ase_calculator calculator = ani_ase_calculator(args.network_type) elif args.implementation == KHAN: from khan_calculator import khan_calculator calculator = khan_calculator(args.network_type, args.khan_network, args.numb_networks) #assert args.cif_file.endswith('.cif') or args.cif_file.endswith('.xyz') if args.cif_file.endswith('.mae'): st = next(StructureReader(args.cif_file)) if args.truncate_box: # reduced size box a = 12.0 deletions = [] for mol in st.molecule: rcom = center_of_mass(st, mol.getAtomIndices()) inbox = [abs(x) < a / 2 for x in rcom] if False in [abs(x) < a / 2 for x in rcom]: deletions.extend(mol.getAtomIndices()) st.deleteAtoms(deletions) rd = rawdataset_from_st([st]) ase_molecs = khan_molec_to_ase_atoms(rd.all_Xs) atoms = ase_molecs[0] if args.truncate_box: # hard coded box #a = 22.6868 vecs = [[a, 0.0, 0.0], [0.0, a, 0.0], [0.0, 0.0, a]] atoms.set_cell(vecs) atoms.set_pbc([True, True, True]) print("after set cell", atoms.get_pbc()) if args.cif_file.endswith('.cif'): atoms = ase_io.read(args.cif_file) if args.box_length is not None: atoms.set_cell([ [args.box_length, 0.0, 0.0], [0.0, args.box_length, 0.0], [0.0, 0.0, args.box_length], ]) atoms.set_pbc([True, True, True]) if args.supercell is not None: atoms = build_supercell(atoms, [args.supercell] * 3) periodic = False not in atoms.get_pbc() print("cell") print(atoms.get_cell()) if periodic: #atoms.wrap() space_group = spacegroup.get_spacegroup(atoms) print("Space group of crystal: %s" % space_group) print("initial unit cell") print(atoms.cell) # this shows how to get unique atoms and there equivalents #scaled_positions = atoms.get_scaled_positions() #unique_positions = space_group.unique_sites(scaled_positions) #all_positions, symmetry_map = space_group.equivalent_sites(unique_positions) #symmetry_groups = defaultdict(list) #for igroup, position in zip(symmetry_map, all_positions): # symmetry_groups[igroup].append(position) #print("unique positions") #for xyz in unique_positions: # print(xyz) #for igroup in sorted(symmetry_groups.keys()): # print("positions in symmetry group %d" % igroup) # for xyz in symmetry_groups[igroup]: # print(xyz) torsions = () if args.torsion is not None: torsions = [( float(args.torsion[0]), int(args.torsion[1]), int(args.torsion[2]), int(args.torsion[3]), )] if args.optimize: # cannot optimize cell until we implement a stress tensor energy = optimize_molecule( atoms, calculator, torsions=torsions, thresh=0.05, optimize_cell=args.relax_cell, ) else: start_time = time.time() energy = single_point_energy(atoms, calculator) print("--- %s seconds ---" % (time.time() - start_time)) if args.dynamics: traj = molecular_dynamics(atoms, calculator, total_time=args.total_time, time_step=args.time_step) if args.cif_file.endswith('.mae'): st = next(StructureReader(args.cif_file)) with StructureWriter("md_path.mae") as writer: for m in traj: st0 = st.copy() st0.setXYZ(m.get_positions()) writer.append(st0) else: with open("md_path.xyz", "w") as fout: xyz_lst = [] for atoms in traj: xyz_lst.append("%d\n" % len(atoms)) species = atoms.get_chemical_symbols() carts = atoms.get_positions() for ch, xyz in zip(species, carts): xyz_lst.append("%s %.8f %.8f %.8f" % (ch, xyz[0], xyz[1], xyz[2])) fout.write("\n".join(xyz_lst)) print("energy of cell (au):", energy) if periodic: space_group = spacegroup.get_spacegroup(atoms) print("Final Space group of crystal: %s" % space_group) print("energy of cell/volume (au):", energy / atoms.get_volume()) print("final unit cell") print(atoms.cell) print("Uncertainty %.4f (kcal/mol)" % (calculator.uncertainty(atoms) * 627.509)) if periodic: outfile = os.path.splitext(args.cif_file)[0] + "_optimized.cif" else: outfile = os.path.splitext(args.cif_file)[0] + "_optimized.xyz" ase_io.write(outfile, atoms) print("final structure written to file: %s" % outfile)
def read_pv_file(pvfile): if not fileutils.is_poseviewer_file(pvfile): raise PoseViewerFileInvalidError(pvfile) reader = StructureReader(pvfile) return (Receptor(reader.next()), tuple(Pose(st, i) for i, st in enumerate(reader)))
for i, group in enumerate(grouped_files): print('making grid', i) with open('{}/run/grid{}_in.sh'.format(save, i), 'w') as f: for s_file in group: out_f = s_file[:12] os.system('mkdir -p {}/{}'.format(save, out_f)) with open('{}/{}/{}.in'.format(save, out_f, out_f), 'w') as f_in: if len(s_file) != 16: continue s = next(StructureReader(ligands + s_file[:4] + '_lig.mae')) c = get_centroid(s) x, y, z = c[:3] f_in.write('GRID_CENTER {},{},{}\n'.format(x, y, z)) f_in.write('GRIDFILE {}.zip\n'.format(out_f)) f_in.write('INNERBOX 15,15,15\n') f_in.write('OUTERBOX 30,30,30\n') f_in.write('RECEP_FILE {}/{}\n'.format(root, s_file)) f.write('#!/bin/bash\n') f.write('cd {}/{}\n'.format(save, out_f)) f.write('$SCHRODINGER/glide -WAIT {}.in\n'.format(out_f)) os.chdir('{}/run'.format(save)) os.system( 'sbatch -p owners -t 02:00:00 -o grid{}.out grid{}_in.sh'.format(
def parse(pdbfile): list(StructureReader(pdbfile))
return complete_a_list if __name__ == '__main__': folder = '/scratch/PI/rondror/combind/bpp_data/MAPK14/structures/aligned_files/' ligands = os.listdir(folder) ligands.remove("4DLI") infile = open('MAPK14_pairwise_alignment', 'rb') paired_strs = pickle.load(infile) infile.close() rmsds = [] for i in range(len(ligands)): ending_1 = '{}/{}_out.mae'.format(ligands[i], ligands[i]) s1 = list(StructureReader(folder + ending_1))[0] arr = [] for j in range(len(ligands)): #to monitor progress print(i, ligands[i], j, ligands[j]) ending_2 = '{}/{}_out.mae'.format(ligands[j], ligands[j]) s2 = list(StructureReader(folder + ending_2))[0] (paired_str_s1, paired_str_s2) = paired_strs[i][j] r_list_s1 = get_all_res(s1) r_list_s2 = get_all_res(s2) r_to_i_map_s1 = map_residues_to_align_index(