def graph_from_smiles(smiles): graph = MolGraph() mol = MolFromSmiles(smiles) Chem.DetectBondStereochemistry(mol, -1) Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(mol, -1) if not mol: raise ValueError("Could not parse SMILES string:", smiles) atoms_by_rd_idx = {} for atom in mol.GetAtoms(): new_atom_node = graph.new_node('atom', features=atom_features(atom), rdkit_ix=atom.GetIdx()) atoms_by_rd_idx[atom.GetIdx()] = new_atom_node for bond in mol.GetBonds(): atom1_node = atoms_by_rd_idx[bond.GetBeginAtom().GetIdx()] atom2_node = atoms_by_rd_idx[bond.GetEndAtom().GetIdx()] new_bond_node = graph.new_node('bond', features=bond_features(bond)) new_bond_node.add_neighbors((atom1_node, atom2_node)) atom1_node.add_neighbors((atom2_node, )) mol_node = graph.new_node('molecule') mol_node.add_neighbors(graph.nodes['atom']) return graph
def load_mols(target, file_path): """Function to load in the 3D molecules Takes a Target object and a file path Returns None""" mols = Chem.SDMolSupplier(file_path) if not mols: return tot = len(mols) if tot == 0: print "No molecules given" return old = -1 print "Adding molecules..." for i, m in enumerate(mols): # Catch none molecules if m is None: print "None molecule", sys.exit() # Print the progress if i * 100 / tot != old: old = i * 100 / tot sys.stdout.write("\r%d%% complete..." % old) sys.stdout.flush() Chem.AssignAtomChiralTagsFromStructure(m) add_new_mol(m, target) old = 100 sys.stdout.write("\r%d%%" % old) sys.stdout.flush() print "\nAdding molecules complete"
def chiral_tags(mol): """ Tag methylene and methyl groups with a chiral tag priority defined from the atom index of the hydrogens """ li_list = [] smarts_ch2 = '[!#1][*]([#1])([#1])([!#1])' atom_sets = mol.GetSubstructMatches(Chem.MolFromSmarts(smarts_ch2)) for atoms in atom_sets: atoms = sorted(atoms[2:4]) prioritized_H = atoms[-1] li_list.append(prioritized_H) mol.GetAtoms()[prioritized_H].SetAtomicNum(9) smarts_ch3 = '[!#1][*]([#1])([#1])([#1])' atom_sets = mol.GetSubstructMatches(Chem.MolFromSmarts(smarts_ch3)) for atoms in atom_sets: atoms = sorted(atoms[2:]) H1 = atoms[-1] H2 = atoms[-2] li_list.append(H1) li_list.append(H2) mol.GetAtoms()[H1].SetAtomicNum(9) mol.GetAtoms()[H2].SetAtomicNum(9) Chem.AssignAtomChiralTagsFromStructure(mol, -1) rdmolops.AssignStereochemistry(mol) for atom_idx in li_list: mol.GetAtoms()[atom_idx].SetAtomicNum(1) return mol
def _prepare_input_file(self, logger=None): from rdkit import Chem import rdkit.Chem.rdmolops as rd self.parameters.input = "input.conf" params = self.parameters # Check input file limit_atoms_ligand = 100 ch.check_limit_number_atoms(params.ligands, limit_atoms_ligand) # Get core of the ligand mol = Chem.MolFromPDBFile(params.core) try: ligand_core = rd.SplitMolByPDBResidues(mol)[params.residue] except KeyError: raise ce.MissResidueFlag("Missing residue flag to specify " + "the ligand core residue name. " + "i.e resname: 'LIG'") # Get sdf full grown ligands ligands_grown = Chem.SDMolSupplier(params.ligands, removeHs=False) fragment_files = [] # For each full grown ligand create neutral fragment with open(params.input, "w") as fout: pass for ligand in ligands_grown: Chem.AssignAtomChiralTagsFromStructure(ligand) try: line, fragment = \ self._create_fragment_from_ligand(ligand, ligand_core) except Exception as e: try: line, fragment = \ self._create_fragment_from_ligand(ligand, ligand_core, substructure=False) except Exception as e: try: # Try to fix symmetry line, fragment = \ self._create_fragment_from_ligand(ligand, ligand_core, symmetry=True) except Exception as e: # Try with second substructure search line, fragment = \ self._create_fragment_from_ligand( ligand, ligand_core, result=1, substructure=False) logger.info(f"Ligand {fragment.file} preprocessed") fragment_files.append(fragment.file) with open(params.input, "a") as fout: fout.write(line + "\n") return fragment_files
def chiral_stereo_check(mol): Chem.SanitizeMol(mol) Chem.DetectBondStereochemistry(mol, -1) Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(mol, -1) return mol
def choose_resonance_structure(mol): """ This function creates all resonance structures of the mol object, counts the number of rotatable bonds for each structure and chooses the one with fewest rotatable bonds (most 'locked' structure) """ resonance_mols = rdchem.ResonanceMolSupplier(mol, rdchem.ResonanceFlags.ALLOW_CHARGE_SEPARATION) res_status = True new_mol = None if not resonance_mols: print("using input mol") new_mol = mol res_status = False for res_mol in resonance_mols: Chem.SanitizeMol(res_mol) n_rot_bonds = Chem.rdMolDescriptors.CalcNumRotatableBonds(res_mol) if new_mol is None: smallest_rot_bonds = n_rot_bonds new_mol = res_mol if n_rot_bonds < smallest_rot_bonds: smallest_rot_bonds = n_rot_bonds new_mol = res_mol Chem.DetectBondStereochemistry(new_mol, -1) rdmolops.AssignStereochemistry(new_mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(new_mol, -1) return new_mol, res_status
def init_search(self, smiles, algorithmname, algorithm_tag): print('Conformational search with a ' + algorithmname + ' method') print('Energy method: ' + self.method) print('Smiles: ' + smiles) print('Job name: ' + self.jobname) #init molecule and optimise mol = Chem.MolFromSmiles(self.smiles) mol = Chem.AddHs(mol, explicitOnly=False) AllChem.EmbedMolecule(mol, randomSeed=int(time.time()), useRandomCoords=True) #write pre optimised molecule self.write_pdb(mol, self.jobname + algorithm_tag + 'preoptimised.pdb') #optimise start molecule AllChem.MMFFOptimizeMolecule(mol) mp = AllChem.MMFFGetMoleculeProperties(mol) ffm = AllChem.MMFFGetMoleculeForceField(mol, mp) #write optimised molecule self.write_pdb(mol, self.jobname + algorithm_tag + 'optimised.pdb') Chem.SanitizeMol(mol) Chem.DetectBondStereochemistry(mol, -1) Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(mol, -1) self.ring_atoms_nr = self.count_ringatoms(mol) print('Number of non aromatic ring atoms:', str(self.ring_atoms_nr)) #create start conformer start_conformer = Conformer(mol) start_conformer.update_molecule('MMFF94') self.min_conformer = start_conformer self.min_energy = start_conformer.energy print('Start energy:', self.min_energy) self.original_conformer = self.min_conformer self.original_smiles = self.get_smiles( self.original_conformer.molecule) start_angles = start_conformer.get_dihedrals() print('Initial angles') start_angles_only = [] for angle in start_angles: print(angle) self.dihedral_atom_id.append( (angle[0], angle[1], angle[2], angle[3])) start_angles_only.append(angle) print('Number of dihedrals:', len(start_angles)) return start_conformer
def toRDKITmol(mol, protidx, sanitize=True, removeHs=False): # Taken from rdkit/Code/GraphMol/FileParsers/PDBParser.cpp conformer = Chem.Conformer(len(protidx)) conformer.Set3D(True) conformer.SetId(0) rdmol = Chem.RWMol() atomlist = [] for ii, i in enumerate(protidx): a = Chem.Atom(mol.element[i]) a.SetFormalCharge(int(mol.charge[i])) info = Chem.AtomPDBResidueInfo(atomName=mol.name[i], serialNumber=int(mol.serial[i]), altLoc=mol.altloc[i], residueName=mol.resname[i], residueNumber=int(mol.resid[i]), chainId=mol.chain[i], insertionCode=mol.insertion[i], occupancy=float(mol.occupancy[i]), tempFactor=float(mol.beta[i]), isHeteroAtom=mol.record[i] == 'HETATM') a.SetMonomerInfo(info) rdmol.AddAtom(a) atomlist.append(a) coor = [float(c) for c in mol.coords[i, :, mol.frame]] conformer.SetAtomPosition(ii, Point3D(coor[0], coor[1], coor[2])) # Correct the atom idx rdmol.AddConformer(conformer) # Here I diverge from the C++ parser because you cannot instantiate Chem.Bond objects in python # I also don't take into account double/triple bonds etc since I don't think we actually store them in Molecule for b in mol._getBonds(): if b[0] in protidx and b[1] in protidx: bond = rdmol.GetBondBetweenAtoms(int(b[0]), int(b[1])) if bond is None: rdmol.AddBond(int(np.where(protidx == b[0])[0]), int(np.where(protidx == b[1])[0]), Chem.BondType.SINGLE) # Proximitybonds I already did by using _getBonds which calls _guessBonds # TODO: Set PDB double bonds # Calculate explicit valence of atoms for a in atomlist: pass if sanitize: if removeHs: Chem.RemoveHs(rdmol) else: Chem.SanitizeMol(rdmol) else: rdmol.UpdatePropertyCache() # Set tetrahedral chirality from 3D co-ordinates Chem.AssignAtomChiralTagsFromStructure(rdmol) StandardPDBResidueChirality(rdmol) return rdmol
def chiral_stereo_check(mol): # avoid sanitization error e.g., dsgdb9nsd_037900.xyz Chem.SanitizeMol(mol, SanitizeFlags.SANITIZE_ALL - SanitizeFlags.SANITIZE_PROPERTIES) Chem.DetectBondStereochemistry(mol,-1) # ignore stereochemistry for now Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(mol,-1) return mol
def updateStereoChemAssignments(self): if not self.__rdMol: return False try: Chem.AssignAtomChiralTagsFromStructure(self.__rdMol) Chem.AssignStereochemistry(self.__rdMol, True, True, True) # self.__rdMol.Debug() except Exception as e: logger.exception("Failing with %s", str(e)) return False
def get_sdf_chiral_center(file_name): mols_suppl = Chem.SDMolSupplier(file_name) for mol in mols_suppl: # mol3的类型=<class 'rdkit.Chem.rdchem.Mol'> #print('类型=',type(mol)) Chem.AssignAtomChiralTagsFromStructure(mol) # 找到分子的手性中心 chiral_center = Chem.FindMolChiralCenters(mol) return chiral_center
def chiral_stereo_check(mol): """ Find and embed chiral information into the model based on the coordinates args: mol - rdkit molecule, with embeded conformer """ Chem.SanitizeMol(mol) Chem.DetectBondStereochemistry(mol, -1) Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(mol, -1) return
def genConf(m, nc, rms, efilter, rmspost): nr = int(AllChem.CalcNumRotatableBonds(m)) #m = Chem.AddHs(m) Chem.AssignAtomChiralTagsFromStructure(m, replaceExistingTags=True) if not nc: nc = 3**nr print(dashedline + "\n | " + ("FULL_MONTE search").ljust(leftcol) + ("|").rjust(rightcol)) #log.Write(" | o "+("COMP: "+str(Params.COMP)+" degrees").ljust(leftcol)+("|").rjust(rightcol)) #log.Write(" | o "+("LEVL: "+str(Params.LEVL)+" force field").ljust(leftcol)+("|").rjust(rightcol)) #log.Write(" | o "+("DEMX: "+str(Params.DEMX)+" kcal/mol").ljust(leftcol)+("|").rjust(rightcol)) print(" | o " + ("EWIN: " + str(efilter) + " kcal/mol").ljust(leftcol) + ("|").rjust(rightcol)) print(" | o " + ("MCNV: " + str(nr) + " ROTATABLE BONDS").ljust(leftcol) + ("|").rjust(rightcol)) #log.Write(" | "+torstring.ljust(leftcol)+("|").rjust(rightcol)) print(" | o " + ("STEP: " + str(nc) + " (ESTIMATED CONFORMER SPACE: " + str(nr**3) + ")").ljust(leftcol) + ("|").rjust(rightcol)) print(dashedline + "\n") if not rms: rms = -1 ids = AllChem.EmbedMultipleConfs(m, numConfs=nc) if len(ids) == 0: ids = m.AddConformer(m.GetConformer, assignID=True) diz = [] diz2 = [] diz3 = [] for id in ids: prop = AllChem.MMFFGetMoleculeProperties(m, mmffVariant="MMFF94s") ff = AllChem.MMFFGetMoleculeForceField(m, prop, confId=id) ff.Minimize() en = float(ff.CalcEnergy()) econf = (en, id) diz.append(econf) if efilter != "Y": n, diz2 = energy_filter(m, diz, efilter) else: n = m diz2 = diz if rmspost != None and n.GetNumConformers() > 1: o, diz3 = postrmsd(n, diz2, rmspost) else: o = n diz3 = diz2 return o, diz3, nr
def _removeHs(data): mols = _parseMolData(data, loadMol=False, useRDKitChemistry=False) ms = [] for molblock in mols: mol = parse_molblock(molblock, useRDKitChemistry=False) props = molblock.split("M END")[1].strip() props = props if len(props) > 1 else None Chem.FastFindRings(mol) mol.UpdatePropertyCache(strict=False) Chem.AssignAtomChiralTagsFromStructure(mol) Chem.AssignStereochemistry(mol, cleanIt=True, force=True) ms.append((remove_hs_from_mol(mol), props)) return _getSDFString(ms)
def molToRDKit(filepath: str): try: m = Chem.MolFromMolFile(filepath, removeHs=False) m = Chem.AddHs(m) Chem.AssignAtomChiralTagsFromStructure(m) # TODO: skipping for now, error with some molecules #AllChem.EmbedMolecule(m,useExpTorsionAnglePrefs=True,useBasicKnowledge=True) #AllChem.MMFFOptimizeMolecule(m) return m except: print(filepath + " is not a valid .mol file") return False
def get_smiles(self, mol): """ Map a molecule name to its corresponding SMILES string. Parameters ---------- mol : RDKit Mol Molecule. """ if self.assign_stereo_from_3d: # do this before removing hydrogens Chem.AssignAtomChiralTagsFromStructure(mol) if self.remove_hydrogens: mol = Chem.RemoveHs(mol) # creates a copy return Chem.MolToSmiles(mol, isomericSmiles=True, canonical=True)
def set_hydrogen_coor_from_pdbmol(refpdbmol, mol, refconfId=-1, confId=-1): newmol = Chem.Mol(mol) hidxs = get_hydrogen_idxs(mol) pdb_2_nhpdb = get_pdb_2_nhpdb(refpdbmol) refconf = refpdbmol.GetConformer(-1) molconf = newmol.GetConformer(-1) molconfid = molconf.GetId() hcount = 0 for atom in refpdbmol.GetAtoms(): if atom.GetSymbol() == 'H': idx = atom.GetIdx() pos = refconf.GetAtomPosition(idx) molconf.SetAtomPosition(hidxs[hcount], pos) hcount += 1 newmol.AddConformer(molconf, assignId=molconfid) Chem.AssignAtomChiralTagsFromStructure(newmol, replaceExistingTags=True) return newmol
def get_smiles(self, molecule): """ Get smiles fromt mol """ molecule_copy = copy.deepcopy(molecule) test_molecule = Chem.Mol(molecule_copy) test_molecule = Chem.RemoveHs(test_molecule) Chem.SanitizeMol(test_molecule) Chem.DetectBondStereochemistry(test_molecule, -1) Chem.AssignStereochemistry(test_molecule, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(test_molecule, -1) smiles = Chem.MolToSmiles(test_molecule, isomericSmiles=True) return smiles
def FindMatchCID(fn, CidSmilesDf): if os.path.exists("%s/%s/%s.list" % (args.ligandfolder, fn.split('/')[-1].split(".")[0], fn.split('/')[-1].split(".")[0])): return print("Already Computed") if not os.path.isdir("%s/%s" % (args.ligandfolder, fn.split('/')[-1].split(".")[0])): os.makedirs("%s/%s" % (args.ligandfolder, fn.split('/')[-1].split(".")[0])) print(fn) start = time.time() # PdbLig is the pdb ligand cast as mol object PdbLig = Chem.MolFromMolFile(fn) Chem.AssignAtomChiralTagsFromStructure(PdbLig) Chem.AssignStereochemistry(PdbLig, cleanIt=False, force=False, flagPossibleStereoCenters=True) # Create Fingerprint For ligand fp1 = FingerprintingFx(Chem.RemoveHs(PdbLig)) match_cid = [] for index, row in CidSmilesDf.iterrows(): # Takes 20 seconds mc = Chem.RemoveHs(row['Mol']) fp2 = FingerprintingFx(mc) # preliminary check if (fp1 & fp2) == fp2: if PdbLig.HasSubstructMatch(row['Mol']): match_cid.append(index) pickle.dump( match_cid, open( "%s/%s/%s.list" % (args.ligandfolder, fn.split('/')[-1].split(".")[0], fn.split('/')[-1].split(".")[0]), "wb")) print("Finished analysing %s in %s s" % (fn, time.time() - start)) return fn, match_cid
def _get_stereo_labels_rdkit(molstr, propgetter): from rdkit import Chem mol = Chem.MolFromMolBlock(molstr, False, False) # if kekulizing fails, then e.g. [R1]P(=O)([O-])[R2] will be chiral. flags_warn = (Chem.SanitizeFlags.SANITIZE_KEKULIZE | Chem.SanitizeFlags.SANITIZE_PROPERTIES) # raises an exception on invalid input Chem.SanitizeMol(mol, Chem.SanitizeFlags.SANITIZE_ALL & ~flags_warn) # warns about invalid input, but keeps going try: Chem.SanitizeMol(mol, flags_warn) except ValueError as e: print(' RDKit-Warning: ' + str(e).strip()) Chem.AssignAtomChiralTagsFromStructure(mol) Chem.AssignStereochemistry(mol, True, True) return [propgetter(a) for a in mol.GetAtoms()]
noconff = open('chembl_20_chiral.noconfs.smi', 'w+') for i, line in enumerate(gzip.open('../Data/chembl_20_chiral.smi.gz')): line = line.strip().decode().split(' ') mol = Chem.MolFromSmiles(line[0]) if not mol: continue cents = Chem.FindMolChiralCenters(mol, includeUnassigned=True) if len([y for x, y in cents if y == '?']): continue nm = line[1] csmi = Chem.MolToSmiles(mol, True) for j in range(100): mh = Chem.AddHs(mol) ok = AllChem.EmbedMolecule(mh, randomSeed=j + 1) if ok >= 0: Chem.AssignAtomChiralTagsFromStructure(mh) newm = Chem.RemoveHs(mh) smi = Chem.MolToSmiles(newm, True) if smi != csmi: print('%d %d %s:\n%s\n%s' % (i, j, nm, csmi, smi)) print('%s %s %d' % (line[0], line[1], j + 1), file=outf) if v is not None: v.ShowMol(mh, name='%s-%d' % (nm, j), showOnly=False) break # move immediately onto the next molecule else: print('noconf %d %d %s: %s' % (i, j, nm, line[0])) print('%s %s %d' % (line[0], line[1], j + 1), file=noconff) print('Done with mol %d' % i)
def generate_graph(smiles, label=None): mol = MolFromSmiles(smiles) Chem.SanitizeMol(mol) Chem.DetectBondStereochemistry(mol, -1) Chem.AssignStereochemistry(mol, flagPossibleStereoCenters=True, force=True) Chem.AssignAtomChiralTagsFromStructure(mol, -1) if not mol: raise ValueError("Could not parse SMILES string:", smiles) SYMBOL = [ 'B', 'C', 'N', 'O', 'F', 'Si', 'P', 'S', 'Cl', 'As', 'Se', 'Br', 'Te', 'I', 'At', 'other' ] HYBRIDIZATION = [ Chem.rdchem.HybridizationType.SP, Chem.rdchem.HybridizationType.SP2, Chem.rdchem.HybridizationType.SP3, Chem.rdchem.HybridizationType.SP3D, Chem.rdchem.HybridizationType.SP3D2, 'other', ] num_atom = Chem.RemoveHs(mol).GetNumAtoms() symbol = np.zeros((num_atom, 16), np.uint8) hybridization = np.zeros((num_atom, 6), np.uint8) degree = np.zeros((num_atom, 6), np.uint8) num_h = np.zeros((num_atom, 5), np.uint8) chirality = np.zeros((num_atom, 3), np.uint8) aromatic = np.zeros((num_atom, 1), np.uint8) formal_charge = np.zeros((num_atom, 1), np.float32) radical_electrons = np.zeros((num_atom, 1), np.float32) for i in range(num_atom): atom = mol.GetAtomWithIdx(i) symbol[i] = one_of_k_encoding_unk(atom.GetSymbol(), SYMBOL) hybridization[i] = one_of_k_encoding_unk(atom.GetHybridization(), HYBRIDIZATION) degree[i] = one_of_k_encoding_unk(atom.GetDegree(), [0, 1, 2, 3, 4, 5]) num_h[i] = one_of_k_encoding_unk( atom.GetTotalNumHs(includeNeighbors=True), [0, 1, 2, 3, 4]) try: chirality[i] = one_of_k_encoding_unk(atom.GetProp('_CIPCode'), ['R', 'S', 'unknown']) except: chirality[i] = one_of_k_encoding_unk(atom.GetChiralTag(), \ ['CHI_TETRAHEDRAL_CW', 'CHI_TETRAHEDRAL_CCW', 'CHI_UNSPECIFIED']) aromatic[i] = atom.GetIsAromatic() formal_charge[i] = atom.GetFormalCharge() radical_electrons[i] = atom.GetNumRadicalElectrons() # # abundant features # # won't bring substantial change to predictive performance, sometimes even worse # AtomicWeight = np.zeros((num_atom, 1), np.float32) # AtomicNumber = np.zeros((num_atom, 1), np.float32) # Rvdw = np.zeros((num_atom, 1), np.float32) # RCovalent = np.zeros((num_atom, 1), np.float32) # DefaultValence = np.zeros((num_atom, 1), np.float32) # valence = np.zeros((num_atom, 1), np.float32) # NOuterElecs = np.zeros((num_atom, 1), np.float32) # ring = np.zeros((num_atom, 7), np.uint8) # acceptor = np.zeros((num_atom, 1), np.uint8) # donor = np.zeros((num_atom, 1), np.uint8) # for i in range(num_atom): # atom = mol.GetAtomWithIdx(i) # AtomicNum = atom.GetAtomicNum() # AtomicNumber[i] = AtomicNum # AtomicWeight[i] = Chem.GetPeriodicTable().GetAtomicWeight(AtomicNum) # Rvdw[i] = Chem.GetPeriodicTable().GetRvdw(AtomicNum) # (van der Waals radius) # RCovalent[i] = Chem.GetPeriodicTable().GetRcovalent(AtomicNum) #(covalent radius) # DefaultValence[i] = Chem.GetPeriodicTable().GetDefaultValence(AtomicNum) # valence[i] = atom.GetExplicitValence() # NOuterElecs[i] = Chem.GetPeriodicTable().GetNOuterElecs(AtomicNum) # ring[i] = [int(atom.IsInRing()), int(atom.IsInRingSize(3)), \ # int(atom.IsInRingSize(4)), int(atom.IsInRingSize(5)), \ # int(atom.IsInRingSize(6)), int(atom.IsInRingSize(7)), int(atom.IsInRingSize(8))] # factory = ChemicalFeatures.BuildFeatureFactory(os.path.join(RDConfig.RDDataDir, 'BaseFeatures.fdef')) # feature = factory.GetFeaturesForMol(mol) # for t in range(0, len(feature)): # if feature[t].GetFamily() == 'Donor': # for i in feature[t].GetAtomIds(): # donor[i] = 1 # elif feature[t].GetFamily() == 'Acceptor': # for i in feature[t].GetAtomIds(): # acceptor[i] = 1 num_bond = mol.GetNumBonds() if num_bond == 0: num_bond = 1 # except error caused by CH4, NH3 bond_feat = np.zeros((num_bond * 2, 10), np.int16) bond_index = np.zeros((num_bond * 2, 2), np.int16) BOND_TYPE = [ Chem.rdchem.BondType.SINGLE, Chem.rdchem.BondType.DOUBLE, Chem.rdchem.BondType.TRIPLE, Chem.rdchem.BondType.AROMATIC, ] BOND_STEREO = ["STEREONONE", "STEREOANY", "STEREOZ", "STEREOE"] ij = 0 for i in range(num_atom): for j in range(num_atom): if i == j: continue bond = mol.GetBondBetweenAtoms(i, j) if bond is not None: atom1 = mol.GetAtomWithIdx(i) atom2 = mol.GetAtomWithIdx(j) bond_index[ij] = [i, j] bond_type = one_of_k_encoding(bond.GetBondType(), BOND_TYPE) bond_ring = [bond.GetIsConjugated(), bond.IsInRing()] bond_stereo = one_of_k_encoding(str(bond.GetStereo()), BOND_STEREO) bond_feat[ij] = bond_type + bond_ring + bond_stereo ij += 1 atom_feat = np.concatenate([symbol, hybridization, degree, num_h, chirality, \ aromatic, formal_charge, radical_electrons], -1) graph = Graph( smiles, atom_feat, bond_feat, bond_index, np.array(label).reshape((1, -1)), ) return graph
2 1 1 6 2 3 1 0 2 4 1 0 4 5 2 0 4 6 1 0 M END""") Draw.MolToImageFile( mol, '/drug_development/studyRdkit/st_rdcit/img/mol51.jpg', legend='L-alanin' ) # L-丙氨酸 # 根据结构指定原子手性标记 Chem.AssignAtomChiralTagsFromStructure(mol) # 找到分子的手性中心 chiral_center = Chem.FindMolChiralCenters(mol) print(chiral_center) # [(1, 'S')] # 在smiles中也有该性质 sm = Chem.MolToSmiles(mol) print(sm) # C[C@H](N)C(=O)O m2 = Chem.MolFromSmiles(sm) Chem.AssignAtomChiralTagsFromStructure(m2) chiral_center = Chem.FindMolChiralCenters(m2) print(chiral_center) # [(1, 'S')] # 当以非异构体的形式输出读取时,因为分子不在有构象所以手性信息会丢失 m3 = Chem.MolToSmiles(mol, isomericSmiles=False) print(m3) # CC(N)C(=O)O
# print(p.getName(), p.getSpeed()) if p.getSpeed() > speed: platform = p speed = p.getSpeed() if platform.getName() == 'CUDA' or platform.getName() == 'OpenCL': platform.setPropertyDefaultValue('Precision', 'mixed') print('Set precision for platform', platform.getName(), 'to mixed') # Read the molfile into RDKit, add Hs and create an openforcefield Molecule object print('Reading ligand') rdkitmol = Chem.MolFromMolFile(mol_in) print('Adding hydrogens') rdkitmolh = Chem.AddHs(rdkitmol, addCoords=True) # ensure the chiral centers are all defined Chem.AssignAtomChiralTagsFromStructure(rdkitmolh) ligand_mol = Molecule(rdkitmolh) print('Preparing system') # Initialize a SystemGenerator using the GAFF for the ligand and tip3p for the water. forcefield_kwargs = { 'constraints': app.HBonds, 'rigidWater': True, 'removeCMMotion': False, 'hydrogenMass': 4 * unit.amu } system_generator = SystemGenerator( forcefields=['amber/ff14SB.xml', 'amber/tip3p_standard.xml'], small_molecule_forcefield='gaff-2.11', molecules=[ligand_mol], forcefield_kwargs=forcefield_kwargs)