def get_sd_data(mol, tag): try: if oechem.OEHasSDData(mol, tag): return oechem.OEGetSDData(mol, tag) if oechem.OEHasSDData(mol.GetActive(), tag): return oechem.OEGetSDData(mol.GetActive(), tag) except AttributeError as e: print(e) return ""
def GetScoreToCmp(mol): if oechem.OEHasSDData(mol, "ShapeTanimoto"): # sort by shape tanimoto if oechem.OEHasSDData(mol, "TanimotoCombo"): return float(oechem.OEGetSDData(mol, "TanimotoCombo")) return float(oechem.OEGetSDData(mol, "ShapeTanimoto")) else: # sort by shape tversky if oechem.OEHasSDData(mol, "TverskyCombo"): return float(oechem.OEGetSDData(mol, "TverskyCombo")) return float(oechem.OEGetSDData(mol, "ShapeTversky"))
def extractXY(fname, tag): ifs = oechem.oemolistream() ifs.SetConfTest(oechem.OEAbsoluteConfTest()) if not ifs.open(fname): oechem.OEThrow.Warning("Unable to open %s for reading" % fname) xlist = [] ylist = [] for mol in ifs.GetOEMols(): for j, conf in enumerate(mol.GetConfs()): xlist.append(int(mol.GetTitle())) try: ylist.append(float(oechem.OEGetSDData(conf, tag))) except ValueError as e: print("Missing tag data for mol {}, conf {}! Skipping.".format( mol.GetTitle(), j)) print(e) xlist.pop() ### convert to numpy array, take relative e, convert to kcal/mol ylist = np.array(ylist) ylist = ylist - ylist[0] ylist = 627.5095 * ylist return xlist, ylist
def main(**kwargs): outfn = os.path.splitext(opt['infn'])[0] + '_' + opt['suffix'] + '.mol2' success = False ### Read in .sdf file and distinguish each molecule's conformers ifs = oechem.oemolistream() ifs.SetConfTest(oechem.OEAbsoluteConfTest()) if not ifs.open(opt['infn']): oechem.OEThrow.Warning("Unable to open %s for reading" % opt['infn']) return for mol in ifs.GetOEMols(): if mol.GetTitle() == opt['title']: # write out all confs in this mol if no SD tag is specified if opt['sdtag'] == "": success = True write_conf_mol(outfn, mol) return # look for the conformer in this mol with specific SD tag value for i, conf in enumerate(mol.GetConfs()): if oechem.OEGetSDData(conf, opt['sdtag']) == opt['value']: success = True write_conf_mol(outfn, conf) if not success: print("\n** Found no confs matching your criteria. **") ifs.close()
def nfragments_score(molecule): overlapping_fragments = oechem.OEGetSDData(molecule, 'overlapping_fragments') if overlapping_fragments == '': return 0 else: return -len(overlapping_fragments.split(','))
def SDF2CSV(ifs, csv): taglist = [] # read through once to find all unique tags for mol in ifs.GetOEGraphMols(): for dp in oechem.OEGetSDDataPairs(mol): if dp.GetTag() not in taglist: taglist.append(dp.GetTag()) ifs.rewind() # print out column labels header = "Title" for tag in taglist: header += ",%s" % tag header += '\n' csv.write(header) # build csv file for mol in ifs.GetOEGraphMols(): line = [mol.GetTitle()] for tag in taglist: if oechem.OEHasSDData(mol, tag): value = oechem.OEGetSDData(mol, tag) else: value = '' line.append(',') line.append(value) csv.write(''.join(line)) csv.write('\n')
def generate_restricted_conformers_star(args): core_smarts_list = [ 'C1(CCOc2ccccc12)C(=O)Nc1cncc2ccccc12', # benzopyran-linker-isoquinoline 'C(=O)Nc1cncc2ccccc12', # linker-isoquinoline ] mols = [ generate_restricted_conformers(*args, core_smarts=core_smarts) for core_smarts in core_smarts_list ] # Sprint 5 special: Select unproblematic enantiomers by energy if mols[1] is None: return mols[0] try: from openeye import oechem energies = [ float(oechem.OEGetSDData(mol, 'MMFF_internal_energy')) for mol in mols ] if energies[0] > energies[1] + 100: return mols[1] else: return mols[0] except Exception as e: print(e) return None
def get_result(self, query_id): cur_rank = list() url = self.args.url + "/queries/{}/".format(query_id) response = None tries = 0 while response == None or data["status"]["job"] != "COMPLETED": time.sleep(60 * tries) tries += 1 response = requests.get(url) data = response.json() results_url = data["results"] results_data = requests.get(self.args.url + results_url) with tempfile.NamedTemporaryFile(suffix='.oeb', mode='wb', delete=False) as temp: temp.write(results_data.content) temp.flush() with oechem.oemolistream(temp.name) as results: for mol in results.GetOEGraphMols(): cur_rank.append( (oechem.OEMolToSmiles(mol), mol.GetTitle(), float(oechem.OEGetSDData(mol, 'TanimotoCombo')), self.baitset[0], False)) os.remove(temp.name) return cur_rank
def get_results(self): self.cur_scores = {} for query_id in self.query_id_list: url = self.args.url + "/queries/{}/".format(query_id) response = None tries = 0 while response == None or data["status"]["job"] != "COMPLETED": tries += 1 time.sleep(tries) response = requests.get(url) data = response.json() results_url = data["results"] results_data = requests.get(self.args.url + results_url) with tempfile.NamedTemporaryFile(suffix='.oeb', mode='wb', delete=False) as temp: temp.write(results_data.content) temp.flush() with oechem.oemolistream(temp.name) as results: for mol in results.GetOEGraphMols(): if self.dataset_infos[1][ mol.GetTitle()] not in self.baitset[1]: tanimoto_combo = float( oechem.OEGetSDData(mol, "TanimotoCombo")) if mol.GetTitle() in self.cur_scores.keys(): if self.cur_scores[ mol.GetTitle()][0] < tanimoto_combo: self.cur_scores[mol.GetTitle()] = ( tanimoto_combo, mol.CreateCopy()) else: self.cur_scores[mol.GetTitle()] = ( tanimoto_combo, mol.CreateCopy()) os.remove(temp.name)
def score(mol): text = oechem.OEGetSDData(mol, 'docking_score') try: score = float(text) return score except Exception as e: return 0
def RenderData(image, mol, tags): from openeye import oechem from openeye import oedepict data = [] for tag in tags: value = "N/A" if oechem.OEHasSDData(mol, tag): value = oechem.OEGetSDData(mol, tag) data.append((tag, value)) nrdata = len(data) tableopts = oedepict.OEImageTableOptions( nrdata, 2, oedepict.OEImageTableStyle_LightBlue) tableopts.SetColumnWidths([10, 20]) tableopts.SetMargins(2.0) tableopts.SetHeader(False) tableopts.SetStubColumn(True) table = oedepict.OEImageTable(image, tableopts) for row, (tag, value) in enumerate(data): cell = table.GetCell(row + 1, 1) table.DrawText(cell, tag + ":") cell = table.GetBodyCell(row + 1, 1) table.DrawText(cell, value)
def generate_restricted_conformers_star(args): core_smarts_list = [ 'C1(CCOc2ccccc12)C(=O)Nc1cncc2ccccc12', # benzopyran-linker-isoquinoline 'CNc1cncc2ccccc12', # linker-isoquinoline 'c1cncc2ccccc12', # isoquinoline ] # Build with all core_smarts options mols = [ generate_restricted_conformers(*args, core_smarts=core_smarts) for core_smarts in core_smarts_list ] # Prune unsuccessful builds mols = [ mol for mol in mols if mol!=None ] # DEBUG if len(mols) == 0: # No options available logging.warning('No core_smarts variations succeeded.') return None if len(mols) == 1: # Return the only choice return mols[0] try: # Prefer the second option if strain energy of first option is poor from openeye import oechem energies = [ float(oechem.OEGetSDData(mol, 'MMFF_internal_energy')) for mol in mols ] if energies[0] > energies[1] + 100: return mols[1] else: return mols[0] except Exception as e: logging.warning(e) return None
def min_ffxml(mol, ffxml): # make copy of the input mol oe_mol = oechem.OEGraphMol(mol) try: # create openforcefield molecule ==> prone to triggering Exception off_mol = Molecule.from_openeye(oe_mol) # load in force field ff = ForceField(ffxml) # create components for OpenMM system topology = Topology.from_molecules(molecules=[off_mol]) # create openmm system ==> prone to triggering Exception #system = ff.create_openmm_system(topology, charge_from_molecules=[off_mol]) system = ff.create_openmm_system(topology) except Exception as e: smilabel = oechem.OEGetSDData(oe_mol, "SMILES QCArchive") print( ' >>> openforcefield failed to create OpenMM system: ' f"'{oe_mol.GetTitle()}' '{smilabel}'") print(f"{e}\n") return print(" >>> successful OpenMM system creation for openforcefield " f"mol \"{oe_mol.GetTitle()}\"")
def generate_training_input(mol_file): ''' :param mol_file: str :return: pd.DataFrame ''' ifs = oechem.oemolistream(mol_file) training_data = [] for mol in ifs.GetOEGraphMols(): energy = float(oechem.OEGetSDData(mol, ENERGY_KEY)) sf_elements = get_sf_elements(mol) dihe_inchi = get_dihedral_inchi_key(mol) data = [dihe_inchi, energy] data.extend(sf_elements) training_data.append(data) ifs.close() columns = [INCHI_KEY, ENERGY_KEY] num_sf_elements = len(training_data[0]) - 2 sf_columns = ['sf_%d' % (i + 1) for i in range(num_sf_elements)] columns.extend(sf_columns) df = pd.DataFrame(training_data, columns=columns) # calculate relative energy for each profile grouped = df.loc[:, [INCHI_KEY, ENERGY_KEY]].groupby(INCHI_KEY) df2 = grouped.transform(lambda x: x - x.min()) df[ENERGY_KEY] = df2[ENERGY_KEY] return df
def has_ic50(mol): """Return True if this molecule has fluorescence IC50 data""" from openeye import oechem try: pIC50 = oechem.OEGetSDData(mol, 'f_avg_pIC50') pIC50 = float(pIC50) return True except Exception as e: return False
def main(argv=[__name__]): itf = oechem.OEInterface(InterfaceData, argv) if not (itf.HasDouble("-min") or itf.HasDouble("-max")): oechem.OEThrow.Fatal("Please set a filter value with -min or -max") ifs = oechem.oemolistream() if not ifs.open(itf.GetString("-i")): oechem.OEThrow.Fatal("Unable to open %s for reading" % itf.GetString("-i")) if not oechem.OEIsSDDataFormat(ifs.GetFormat()): oechem.OEThrow.Fatal( "Only works for input file formats that support SD data (sdf,oeb,csv)" ) ofs = oechem.oemolostream() if not ofs.open(itf.GetString("-o")): oechem.OEThrow.Fatal("Unable to open %s for writing" % itf.GetString("-i")) if not oechem.OEIsSDDataFormat(ofs.GetFormat()): oechem.OEThrow.Fatal( "Only works for output file formats that support SD data \ (sdf,oeb,csv)") tag = itf.GetString("-tag") minval = float("-inf") if itf.HasDouble("-min"): minval = itf.GetDouble("-min") maxval = float("inf") if itf.HasDouble("-max"): maxval = itf.GetDouble("-max") for mol in ifs.GetOEGraphMols(): if not oechem.OEHasSDData(mol, tag): oechem.OEThrow.Warning("Unable to find %s tag on %s" % (tag, mol.GetTitle())) continue value = oechem.OEGetSDData(mol, tag) try: tagvalue = float(value) except ValueError: oechem.OEThrow.Warning("Failed to convert (%s) to a number in %s" % (value, mol.GetTitle())) continue if tagvalue < minval: continue if tagvalue > maxval: continue oechem.OEWriteMolecule(ofs, mol)
def Rename(ifs, ofs, fieldname): for mol in ifs.GetOEGraphMols(): if oechem.OEHasSDData(mol, fieldname): mol.SetTitle(oechem.OEGetSDData(mol, fieldname)) else: title = mol.GetTitle() oechem.OEThrow.Warning( "Renaming of molecule %s failed; no field %s" % (title, fieldname)) oechem.OEWriteMolecule(ofs, mol)
def dock_molecule(molecule, default_receptor='x0387'): """ Dock the specified molecules, writing out to specified file Parameters ---------- molecule : OEMol The molecule to dock default_receptor : str, optional, default='0387' The default receptor to dock to Returns ------- all_docked_molecules : list of OEMol All docked molecules """ import os import oechem # Make a copy of the molecule molecule = oechem.OEMol(molecule) # Extract list of corresponding receptor(s) fragments = list() fragments = oechem.OEGetSDData(molecule, "fragments").split(',') fragments = [ fragment for fragment in fragments if os.path.exists(f'../receptors/Mpro-{fragment}-receptor.oeb.gz') ] if len(fragments) == 0: fragments = [default_receptor] # Dock them all_docked_molecules = list() for fragment in fragments: molecule_to_dock = oechem.OEMol(molecule) import os receptor_filename = os.path.join( f'../receptors/Mpro-{fragment}-receptor.oeb.gz') oechem.OESetSDData(molecule_to_dock, "fragments", fragment) # Enumerate reasonable protomers/tautomers from openeye import oequacpac protomer = oechem.OEMol() protomers = [ oechem.OEMol(protomer) for protomer in oequacpac.OEGetReasonableProtomers(molecule_to_dock) ] docked_molecules = dock_molecules_to_receptor(receptor_filename, protomers) all_docked_molecules += docked_molecules return all_docked_molecules
def is_active(molecule): """ """ from openeye import oechem value = oechem.OEGetSDData(molecule, 'IC50 (uM)') try: IC50 = float(value) if (IC50 < 99.0): return True except: pass return False
def GetUrlSDF2SMI(url, fout, ntries=20, poll_wait=10): '''Get PubChem SDF.GZ, convert to SMILES using the SD tag PUBCHEM_OPENEYE_CAN_SMILES or PUBCHEM_OPENEYE_ISO_SMILES, and PUBCHEM_COMPOUND_CID or PUBCHEM_COMPOUND_SID for name.''' import openeye.oechem as oechem def HandleOEErrors(oeerrs, nowarn): errstr = oeerrs.str() for line in errstr.split('\n'): if not line.rstrip(): continue if re.search('Warning', line, re.I) and nowarn: continue sys.stderr.write("%s\n" % line) oeerrs.clear() fout_tmp = tempfile.NamedTemporaryFile(prefix='pubchem_ftp_', suffix='.sdf.gz', delete=False) GetUrl(url, fout_tmp, ntries, poll_wait) fpath_tmp = fout_tmp.name logging.debug('fpath_tmp = %s' % fpath_tmp) fout_tmp.close() ims = oechem.oemolistream(fpath_tmp) ims.SetFormat(oechem.OEFormat_SDF) ims.Setgz(True) mol = oechem.OEGraphMol() nbytes = 0 oeerrs = oechem.oeosstream() oechem.OEThrow.SetOutputStream(oeerrs) while oechem.OEReadMolecule(ims, mol): cid = oechem.OEGetSDData(mol, 'PUBCHEM_COMPOUND_CID') cansmi = oechem.OEGetSDData(mol, 'PUBCHEM_OPENEYE_CAN_SMILES') isosmi = oechem.OEGetSDData(mol, 'PUBCHEM_OPENEYE_ISO_SMILES') buff = ("%s %s\n" % (isosmi, cid)) fout.write(buff) nbytes += len(buff) HandleOEErrors(oeerrs, True) os.remove(fpath_tmp) return nbytes
def read_molecules(file_path, verbose=True): """ Read molecules from an OpenEye-supported file. Parameters ---------- file_path : str Filename from which molecules are to be read (e.g. mol2, sdf) Returns ------- molecules : list of OEMol List of molecules read from file """ warnings.warn(DEPRECATION_WARNING_TEXT, PendingDeprecationWarning) from openeye import oechem from openforcefield.utils import get_data_file_path if not os.path.exists(file_path): built_in = get_data_file_path(f"molecules/{file_path}") if not os.path.exists(built_in): raise Exception(f"File '{file_path}' not found.") file_path = built_in if verbose: print(f"Loading molecules from '{file_path}'...") start_time = time.time() molecules = list() input_molstream = oechem.oemolistream(file_path) flavor = oechem.OEIFlavor_Generic_Default | oechem.OEIFlavor_MOL2_Default | oechem.OEIFlavor_MOL2_Forcefield input_molstream.SetFlavor(oechem.OEFormat_MOL2, flavor) molecule = oechem.OECreateOEGraphMol() while oechem.OEReadMolecule(input_molstream, molecule): # If molecule has no title, try getting SD 'name' tag if molecule.GetTitle() == '': name = oechem.OEGetSDData(molecule, 'name').strip() molecule.SetTitle(name) # Append to list. molecule_copy = oechem.OEMol(molecule) molecules.append(molecule_copy) input_molstream.close() if verbose: print(f"{len(molecules)} molecules read") end_time = time.time() elapsed_time = end_time - start_time if verbose: print(f"{elapsed_time:.3f} s elapsed") return molecules
def plotSDF(infile, tag, figname='lineplot.png'): """ Parameters ---------- """ ### Read in .sdf file and distinguish each molecule's conformers ifs = oechem.oemolistream() ifs.SetConfTest(oechem.OEAbsoluteConfTest()) if not ifs.open(infile): oechem.OEThrow.Warning("Unable to open %s for reading" % infile) return xlist = [] ylist = [] for mol in ifs.GetOEMols(): print(mol.GetTitle(), mol.NumConfs()) for j, conf in enumerate(mol.GetConfs()): try: ylist.append(float(oechem.OEGetSDData(conf, tag))) xlist.append(int(mol.GetTitle())) except ValueError as err: pass # mols not converged may not have tag ### convert to numpy array, take relative e, convert to kcal/mol ylist = np.array(ylist) ylist = ylist - ylist[0] ylist = 627.5095 * ylist ### Plot. xlabel = 'conformation number' ylabel = "Relative energy (kcal/mol)" fig = plt.figure() # ax = fig.gca() # ax.set_xticks(np.arange(-1,RefNumConfs+1,2)) plt.ylabel(ylabel, fontsize=14) plt.xlabel(xlabel, fontsize=14) plt.scatter(xlist, ylist) # plt.plot(xlist, ylist) plt.ylim(-1, 16) # plt.xticks(range(RefNumConfs),xlabs,fontsize=12) # plt.yticks(fontsize=12) plt.grid() plt.savefig(figname, bbox_inches='tight') plt.show()
def find_string_tag(infile): # read input file ifs = oechem.oemolistream() ifs.SetConfTest(oechem.OEAbsCanonicalConfTest()) if not ifs.open(infile): oechem.OEThrow.Warning("Unable to open input file for reading") # loop through and evaluate tags for mol in ifs.GetOEMols(): for conf in mol.GetConfs(): mytag = oechem.OEGetSDData(conf, 'SMILES QCArchive') count1 = mytag.count('S') count2 = mytag.count('P') count3 = mytag.count('C#N') count4 = mytag.count('N/N') print(f"{conf.GetTitle()}\t{count1}\t{count2}\t{count3}\t{count4}")
def min_mmff94x(mol, ofs, mmff94s=False): """ Minimize the mol with MMFF94 or MMFF94S force field. Parameters ---------- mol : OpenEye single-conformer molecule ofs : OpenEye output filestream mmff94s : Boolean True to minimize with MMFF94S """ # make copy of the input mol oe_mol = oechem.OEGraphMol(mol) # set general energy options along with the run type specification optSzybki = oeszybki.OESzybkiOptions() optSzybki.SetSolventModel(oeszybki.OESolventModel_NoSolv) optSzybki.SetOptimizerType(oeszybki.OEOptType_BFGS) # minimize with input charges not mmff94(s) charges # https://docs.eyesopen.com/toolkits/python/szybkitk/examples.html#optimization-of-all-conformers-of-a-ligand optSzybki.GetSolventOptions().SetChargeEngine(oequacpac.OEChargeEngineNoOp()) # set the particular force field if mmff94s: sdlabel = "MMFF94S" optSzybki.SetForceFieldType(oeszybki.OEForceFieldType_MMFF94S) else: sdlabel = "MMFF94" optSzybki.SetForceFieldType(oeszybki.OEForceFieldType_MMFF94) # generate minimization engine szOpt = oeszybki.OESzybki(optSzybki) # make object to hold szybki results szResults = oeszybki.OESzybkiResults() # perform minimization if not szOpt(oe_mol, szResults): smilabel = oechem.OEGetSDData(oe_mol, "SMILES QCArchive") print( ' >>> MMFF94x minimization failed for %s\n' % smilabel ) energy = szResults.GetTotalEnergy() # save geometry, save energy as tag, write mol to file oechem.OESetSDData(oe_mol, f"Energy {sdlabel}", str(energy)) oechem.OEWriteConstMolecule(ofs, oe_mol)
def min_ffxml(mol, ofs, ffxml): """ Minimize the mol with force field input from FFXML file. Parameters ---------- mol : OpenEye single-conformer molecule ofs : OpenEye output filestream ffxml : string name of FFXML file """ # make copy of the input mol oe_mol = oechem.OEGraphMol(mol) try: # create openforcefield molecule ==> prone to triggering Exception off_mol = Molecule.from_openeye(oe_mol) # load in force field ff = ForceField(ffxml) # create components for OpenMM system topology = Topology.from_molecules(molecules=[off_mol]) # create openmm system ==> prone to triggering Exception #system = ff.create_openmm_system(topology, charge_from_molecules=[off_mol]) system = ff.create_openmm_system(topology) except Exception as e: smilabel = oechem.OEGetSDData(oe_mol, "SMILES QCArchive") print( ' >>> openforcefield failed to create OpenMM system: ' f'{oe_mol.GetTitle()} {smilabel}: {e}') return positions = structure.extractPositionsFromOEMol(oe_mol) # minimize structure with ffxml newpos, energy = run_openmm(topology, system, positions) # save geometry, save energy as tag, write mol to file oe_mol.SetCoords(oechem.OEFloatArray(newpos)) oechem.OESetSDData(oe_mol, "Energy FFXML", str(energy)) oechem.OEWriteConstMolecule(ofs, oe_mol) return
def dock_molecule(molecule, ofs, default_receptor='x0387'): """ Dock the specified molecules, writing out to specified file Parameters ---------- molecule : OEMol The molecule to dock ofs : oechem.oemolostream The filename to stream docked molecules to default_receptor : str, optional, default='0387' The default receptor to dock to """ # Make a copy of the molecule molecule = oechem.OEMol(molecule) import os # Extract list of corresponding receptor(s) import oechem print(f'\n{molecule.GetTitle()}') if oechem.OEHasSDData(molecule, "fragments"): fragments = oechem.OEGetSDData(molecule, "fragments").split(',') print(f'fragments before filter: {fragments}') fragments = [ fragment for fragment in fragments if os.path.exists(f'../receptors/Mpro-{fragment}-receptor.oeb.gz') ] print(f'fragments after filter: {fragments}') if len(fragments) == 0: fragments = [default_receptor] for fragment in fragments: molecule_to_dock = oechem.OEMol(molecule) import os receptor_filename = os.path.join( f'../receptors/Mpro-{fragment}-receptor.oeb.gz') oechem.OESetSDData(molecule_to_dock, "fragments", fragment) # Enumerate reasonable protomers/tautomers from openeye import oequacpac protomer = oechem.OEMol() protomers = [ oechem.OEMol(protomer) for protomer in oequacpac.OEGetReasonableProtomers(molecule_to_dock) ] dock_molecules_to_receptor(receptor_filename, protomers, ofs)
def mols_from_file(mol_file): """ Parses a standard molecule file into chemper molecules using OpenEye toolkits Parameters ---------- mol_file: str relative or full path to molecule containing the molecule file that is accessible from the current working directory Returns ------- mols: list of chemper Mols list of molecules in the mol2 file as chemper Mols """ import os if not os.path.exists(mol_file): from chemper.chemper_utils import get_data_path mol_path = get_data_path(os.path.join('molecules', mol_file)) if not os.path.exists(mol_path): raise IOError( "File '%s' not found locally or in chemper/data/molecules." % mol_file) else: mol_file = mol_path molecules = list() # make Openeye input file stream ifs = oechem.oemolistream(mol_file) oemol = oechem.OECreateOEGraphMol() while oechem.OEReadMolecule(ifs, oemol): # if an SD file, the molecule name may be in the SD tags if oemol.GetTitle() == '': name = oechem.OEGetSDData(oemol, 'name').strip() oemol.SetTitle(name) # Append to list. molecules.append(Mol(oechem.OEMol(oemol))) ifs.close() return molecules
def main(infile): # open multi-molecule, multi-conformer file ifs = oechem.oemolistream() ifs.SetConfTest(oechem.OEAbsCanonicalConfTest()) if not ifs.open(infile): raise FileNotFoundError(f"Unable to open {infile} for reading") mols = ifs.GetOEMols() for i, mol in enumerate(mols): # perceive stereochemistry for mol oechem.OEPerceiveChiral(mol) oechem.OEAssignAromaticFlags(mol, oechem.OEAroModel_MDL) # assign charges to copy of mol # note that chg_mol does NOT have conformers try: chg_mol = charge_mol(mol) except RuntimeError: # perceive stereochem #find_unspecified_stereochem(mol) oechem.OE3DToInternalStereo(mol) # reset perceived and call OE3DToBondStereo, since it may be missed # by OE3DToInternalStereo if it thinks mol is flat mol.ResetPerceived() oechem.OE3DToBondStereo(mol) try: chg_mol = charge_mol(mol) print(f'fixed stereo: {mol.GetTitle()}') except RuntimeError: find_unspecified_stereochem(mol) title = mol.GetTitle() smilabel = oechem.OEGetSDData(mol, "SMILES QCArchive") print(' >>> Charge assignment failed due to unspecified ' f'stereochemistry {title} {smilabel}') continue
def get_fragment_to_parent_atom_mapping(parent_mol, frag_mol): try: mapping_data = oechem.OEGetSDData(frag_mol, FRAGMENT_TO_PARENT_ATOMS_KEY) idx_map = dict( map(int, idx_pair.split('_')) for idx_pair in mapping_data.split('-')) atom_map = {} for frag_idx, parent_idx in idx_map.items(): frag_atom = frag_mol.GetAtom(oechem.OEHasAtomIdx(frag_idx - 1)) parent_atom = parent_mol.GetAtom( oechem.OEHasAtomIdx(parent_idx - 1)) if frag_atom is not None and parent_atom is not None: atom_map[frag_atom] = parent_atom return atom_map except Exception as e: logging.warning(e) return {}
def reorder_sd_props(mol: oechem.OEGraphMol): strain1 = oechem.OEGetSDData(mol, TOTAL_STRAIN_TAG) data_pairs = [(TOTAL_STRAIN_TAG, strain1)] for dp in oechem.OEGetSDDataPairs(mol): if dp.GetTag() == TOTAL_STRAIN_TAG: pass else: data_pairs.append((dp.GetTag(), dp.GetValue())) oechem.OEClearSDData(mol) for k, v in data_pairs: oechem.OESetSDData(mol, k, v) data_pairs = [] for dp in oechem.OEGetSDDataPairs(mol): data_pairs.append((dp.GetTag(), dp.GetValue())) oechem.OEClearSDData(mol) for k, v in data_pairs: oechem.OESetSDData(mol, k, v)