static void Main() { // ----- Object creation ----- Console.WriteLine("Creating some objects:"); ROMol m1 = RWMol.MolFromSmiles("c1ccccc1"); Console.WriteLine(" mol: " + m1 + " " + m1.getNumAtoms()); ROMol m2 = RWMol.MolFromSmiles("c1ccccn1"); Console.WriteLine(" smi: " + m1 + " " + m1.MolToSmiles()); Console.WriteLine(" smi2: " + m2 + " " + m2.MolToSmiles()); ExplicitBitVect fp1 = RDKFuncs.LayeredFingerprintMol(m1); ExplicitBitVect fp2 = RDKFuncs.LayeredFingerprintMol(m2); Console.WriteLine(" sim: " + RDKFuncs.TanimotoSimilarityEBV(fp1, fp2)); //rxnTest(); //smiTest(); morganTest(); Console.WriteLine("Goodbye"); }
public static UInt_Vect GetConnectivityInvariants(ROMol mol, bool includeRingMembership) { var invars = new UInt_Vect((int)mol.getNumAtoms()); RDKFuncs.getConnectivityInvariants(mol, invars, includeRingMembership); return(invars); }
public static string MolFragmentToSmiles(ROMol mol, Int_Vect atomsToUse, Int_Vect bondsToUse = null, Str_Vect atomSymbols = null, Str_Vect bondSymbols = null, bool isomericSmiles = true, bool kekuleSmiles = false, int rootedAtAtom = -1, bool canonical = true, bool allBondsExplicit = false, bool allHsExplicit = false) { return(RDKFuncs.MolFragmentToSmiles(mol, atomsToUse, bondsToUse, atomSymbols, bondSymbols, isomericSmiles, kekuleSmiles, rootedAtAtom, canonical)); }
public static string RDKit_Smiles(string text, object isomericSmiles = null, bool kekuleSmiles = false, object rootedAtAtom = null, object canonical = null, bool allBondsExplicit = false, bool allHsExplicit = false, bool doRandom = false) { var _isomericSmiles = ExcelDnaUtility.ToBoolean(isomericSmiles, true); var _rootedAtAtom = ExcelDnaUtility.ToInt32(rootedAtAtom, -1); var _canonical = ExcelDnaUtility.ToBoolean(canonical, true); if (_isomericSmiles && !kekuleSmiles && _rootedAtAtom == -1 && _canonical && !allBondsExplicit && !allHsExplicit && !doRandom) { return(RDKit_CalcDesc(text, "RDKit_Smiles", mol => RDKit.Chem.MolToSmiles(mol))); } { ROMol mol; if (kekuleSmiles) { var _mol = RWMol.MolFromSmiles(text); RDKFuncs.Kekulize(_mol); mol = _mol; } else { mol = Parse(text); } return(RDKit.Chem.MolToSmiles(mol, _isomericSmiles, kekuleSmiles, _rootedAtAtom, _canonical, allBondsExplicit, allHsExplicit, doRandom)); } }
/// <summary> /// Tries to parses text as SMILES, InChI, or MolBlock and returns RDKit ROMol. /// </summary> /// <param name="molIdent">Text expression of molecule like SMILES, InChI, or MolBlock.</param> /// <returns>RDKit ROMol.</returns> public static ROMol Parse(string molIdent) { if (molIdent == null) { throw new ArgumentNullException(nameof(molIdent)); } var mol = MolecularCache.GetOrAdd(molIdent, a_ident => { string notationType = null; ROMol a_mol; a_mol = RWMol.MolFromSmiles(molIdent); if (a_mol != null) { notationType = "SMILES"; goto L_Found; } using (var rv = new ExtraInchiReturnValues()) { a_mol = RDKFuncs.InchiToMol(molIdent, rv); if (a_mol != null) { notationType = "InChI"; goto L_Found; } } a_mol = RWMol.MolFromMolBlock(molIdent); if (a_mol != null) { RDKFuncs.assignStereochemistryFrom3D(a_mol); notationType = "MolBlock"; goto L_Found; } L_Found: if (a_mol == null) { a_mol = nullMol; } else { if (notationType != null) { a_mol.setProp("source", notationType); } } return(a_mol); }); if (object.ReferenceEquals(mol, nullMol)) { return(null); } return(mol); }
public static UInt_Vect GetFeatureInvariants(ROMol mol) { var invars = new UInt_Vect((int)mol.getNumAtoms()); RDKFuncs.getFeatureInvariants(mol, invars); return(invars); }
public static Double_Vect SlogP_VSA_(ROMol mol, Double_Vect bins = null, bool force = false) { if (bins == null) { bins = new Double_Vect(0); } return(RDKFuncs.calcSlogP_VSA(mol, bins, force)); }
public static ROMol StripMol(ROMol mol) { foreach (var query in saltPatterns) { mol = RDKFuncs.deleteSubstructs(mol, query, true); } return(mol); }
static void Main(string[] args) { var smiles = "c1ccccc1C"; var mol = RWMol.MolFromSmiles(smiles); var re_smi = RDKFuncs.MolToSmiles(mol); Console.WriteLine($"Hello toluene, {re_smi}."); }
public static ExplicitBitVect FoldToTargetDensity(ExplicitBitVect fp, double density = 0.3, int minLength = 64) { while (fp.GetNumOnBits() / fp.Count() > density && fp.Count() / 2 > minLength) { fp = RDKFuncs.FoldFingerprint(fp, 2); } return(fp); }
public static ExplicitBitVect RDKFingerprint(ROMol mol, int minPath = 1, int maxPath = 7, int fpSize = 2048, int nBitsPerHash = 2, bool useHs = true, double tgtDensity = 0, int minSize = 128, bool branchedPaths = true, bool useBondOrder = true, UInt_Vect atomInvariants = null, UInt_Vect fromAtoms = null, SWIGTYPE_p_std__vectorT_std__vectorT_uint32_t_t_t atomBits = null, SWIGTYPE_p_std__mapT_unsigned_int_std__vectorT_std__vectorT_int_t_t_std__lessT_unsigned_int_t_t bitInfo = null) { return(RDKFuncs.RDKFingerprintMol(mol, (uint)minPath, (uint)maxPath, (uint)fpSize, (uint)nBitsPerHash, useHs, tgtDensity, (uint)minSize, branchedPaths, useBondOrder, atomInvariants, fromAtoms, atomBits, bitInfo)); }
public static StringMolMap ParseMolQueryDefFile(string filename, bool standardize = true, string delimiter = "\t", string comment = "//", int nameColumn = 0, int smartsColumn = 1) { var queryDefs = new StringMolMap(); RDKFuncs.parseQueryDefFile(filename, queryDefs, standardize, delimiter, comment, (uint)nameColumn, (uint)smartsColumn); return(queryDefs); }
public static ExplicitBitVect GetMorganFingerprintAsBitVect(ROMol mol, int radius, int nBits = 2048, UInt_Vect invariants = null, UInt_Vect fromAtoms = null, bool useChirality = false, bool useBondTypes = true, bool onlyNonzeroInvariants = false, BitInfoMap atomsSettingBits = null) { if (invariants == null) { invariants = new UInt_Vect(0); } if (fromAtoms == null) { fromAtoms = new UInt_Vect(0); } return(RDKFuncs.getMorganFingerprintAsBitVect(mol, (uint)radius, (uint)nBits, invariants, fromAtoms, useChirality, useBondTypes, onlyNonzeroInvariants, atomsSettingBits)); }
public static SparseIntVectu32 GetMorganFingerprint(ROMol mol, int radius, UInt_Vect invariants = null, UInt_Vect fromAtoms = null, bool useChirality = false, bool useBondTypes = true, bool onlyNonzeroInvariants = false, bool useCounts = true, BitInfoMap atomsSettingBits = null) { if (invariants == null) { invariants = new UInt_Vect(0); } if (fromAtoms == null) { fromAtoms = new UInt_Vect(0); } return(RDKFuncs.MorganFingerprintMol(mol, (uint)radius, invariants, fromAtoms, useChirality, useBondTypes, useCounts, onlyNonzeroInvariants, atomsSettingBits)); }
// static void rxnTest() { // Console.WriteLine( "Reaction tests" ); // var rxn = ChemicalReaction.ReactionFromSmarts("[N:1][C:2].[OH][C:3]=[O:4]>>[C:2][N:1][C:3]=[O:4]"); // var amine = RWMol.MolFromSmiles("CCCN"); // var acid = RWMol.MolFromSmiles("C1CC1CC(=O)O"); // ROMol[] rs = {amine,acid}; // ROMol_Vect rv = new ROMol_Vect(rs); // for(var i=0;i<100000;i++){ // var ps=rxn.runReactants(rv); // if(i%100 == 0) { // Console.WriteLine( "\t{0}", i ); // } // } // Console.WriteLine( "Goodbye" ); // } // static void smiTest() { // Console.WriteLine( "repeatedly from smiles" ); // for(var i=0;i<1000000;i++){ // ROMol m1=RDKFuncs.MolFromSmiles("c1ccccc1"); // if(i%1000 == 0) { // Console.WriteLine( "\t{0}", i ); // } // } // Console.WriteLine( "Goodbye" ); // } static void morganTest() { // ----- Object creation ----- Console.WriteLine("Creating some objects:"); ROMol m1 = RWMol.MolFromSmiles("c1ccccc1"); Console.WriteLine(" mol: " + m1 + " " + m1.getNumAtoms()); ROMol m2 = RWMol.MolFromSmiles("c1ccccn1"); var fp1 = RDKFuncs.MorganFingerprintMol(m1, 2); var fp2 = RDKFuncs.MorganFingerprintMol(m2, 2); Console.WriteLine(" sim: " + RDKFuncs.DiceSimilarity(fp1, fp2)); }
/// <summary> /// Calculated similarity between two fingerprints, /// handles any folding that may need to be done to ensure that they are compatible /// </summary> /// <param name="fp1"></param> /// <param name="fp2"></param> /// <param name="metric">Default is <see cref="TanimotoSimilarity(ExplicitBitVect, ExplicitBitVect)"/></param> /// <returns>The calculated similarity</returns> public static double FingerprintSimilarity(ExplicitBitVect fp1, ExplicitBitVect fp2, Func <ExplicitBitVect, ExplicitBitVect, double> metric = null) { metric = metric ?? TanimotoSimilarity; var sz1 = fp1.GetNumBits(); var sz2 = fp2.GetNumBits(); if (sz1 < sz2) { fp2 = RDKFuncs.FoldFingerprint(fp2, (uint)(sz2 / sz1)); } else if (sz2 < sz1) { fp1 = RDKFuncs.FoldFingerprint(fp1, (uint)(sz1 / sz2)); } return(metric(fp1, fp2)); }
static void Demo() { var toluene = RWMol.MolFromSmiles("Cc1ccccc1"); var mol1 = RWMol.MolFromMolFile(Path.Combine("Data", "input.mol")); var stringWithMolData = new StreamReader(Path.Combine("Data", "input.mol")).ReadToEnd(); var mol2 = RWMol.MolFromMolBlock(stringWithMolData); using (var suppl = new SDMolSupplier(Path.Combine("Data", "5ht3ligs.sdf"))) { while (!suppl.atEnd()) { var mol = suppl.next(); if (mol == null) { continue; } Console.WriteLine(mol.getAtoms().Count); using (var maccs = RDKFuncs.MACCSFingerprintMol(mol)) { Console.WriteLine(ToString(maccs)); } } } using (var gzsuppl = new ForwardSDMolSupplier(new gzstream("Data/actives_5ht3.sdf.gz"))) { while (!gzsuppl.atEnd()) { var mol = gzsuppl.next(); if (mol == null) { continue; } Console.WriteLine(mol.getAtoms().Count); using (var maccs = RDKFuncs.MACCSFingerprintMol(mol)) { Console.WriteLine(ToString(maccs)); } } } }
static void Main(string[] args) { // ----- Object creation ----- Console.WriteLine("Creating some objects:"); ROMol m1 = RWMol.MolFromSmiles("c1ccccc1"); Console.WriteLine(" mol: " + m1 + " " + m1.getNumAtoms()); ROMol m2 = RWMol.MolFromSmiles("c1ccccn1"); Console.WriteLine(" smi: " + m1 + " " + m1.MolToSmiles()); Console.WriteLine(" smi2: " + m2 + " " + m2.MolToSmiles()); ExplicitBitVect fp1 = RDKFuncs.LayeredFingerprintMol(m1); ExplicitBitVect fp2 = RDKFuncs.LayeredFingerprintMol(m2); Console.WriteLine(" sim: " + RDKFuncs.TanimotoSimilarityEBV(fp1, fp2)); //rxnTest(); //smiTest(); //morganTest(); ROMol m3 = RWMol.MolFromSmiles("c1ccccc1"); uint nAtoms = m3.getNumAtoms(true); Console.WriteLine("Bulk memory leak test"); for (uint i = 0; i < 10000; ++i) { ROMol m4 = RWMol.MolFromSmiles("Clc1cccc(N2CCN(CCC3CCC(CC3)NC(=O)c3cccs3)CC2)c1Cl"); if ((i % 1000) == 0) { Console.WriteLine(" Done: " + i); } m4.Dispose(); //GC.Collect(); } Console.WriteLine("Goodbye"); }
static void MakePicture(string smiles, string filename) { int width = 200; int height = 200; RWMol mol = null; mol = RWMol.MolFromSmiles(smiles); if (mol == null) { mol = RWMol.MolFromSmarts(smiles); } if (mol == null) { throw new Exception($"Cannot recognize: '{smiles}'"); } RDKFuncs.prepareMolForDrawing(mol); if (filename.EndsWith(".svg")) { var view = new MolDraw2DSVG(width, height); view.drawMolecule(mol); view.finishDrawing(); using (var w = new StreamWriter(filename)) { w.Write(view.getDrawingText()); Console.WriteLine($"{filename} is drawn."); } } else if (filename.EndsWith(".png")) { var view = new MolDraw2DCairo(width, height); view.drawMolecule(mol, Path.GetFileNameWithoutExtension(filename)); view.finishDrawing(); view.writeDrawingText(filename); } else { throw new Exception($"Not supported: {filename}"); } }
static void CreateSomeObjects() { // ----- Object creation ----- Console.WriteLine("Creating some objects:"); ROMol m1 = RWMol.MolFromSmiles("c1ccccc1"); Console.WriteLine(" mol: " + m1 + " " + m1.getNumAtoms()); ROMol m2 = RWMol.MolFromSmiles("c1ccccn1"); Console.WriteLine(" smi: " + m1 + " " + m1.MolToSmiles()); Console.WriteLine(" smi2: " + m2 + " " + m2.MolToSmiles()); ExplicitBitVect fp1 = RDKFuncs.LayeredFingerprintMol(m1); ExplicitBitVect fp2 = RDKFuncs.LayeredFingerprintMol(m2); Console.WriteLine(" sim: " + RDKFuncs.TanimotoSimilarityEBV(fp1, fp2)); const string SMILES_benzene = "c1ccccc1"; ROMol m3 = RWMol.MolFromSmiles(SMILES_benzene); uint nAtoms = m3.getNumAtoms(true); Console.WriteLine($"The number of atoms in {SMILES_benzene} is {nAtoms}."); }
public static void AssignRadicals(RWMol mol) { RDKFuncs.assignRadicals(mol); }
public static MolSanitizeException_Vect DetectChemistryProblems(ROMol mol, SanitizeFlags sanitizeOps = SanitizeFlags.SANITIZE_ALL) { return(RDKFuncs.detectChemistryProblems(mol, (int)sanitizeOps)); }
public static void DetectBondStereochemistry(ROMol mol, int confId = -1) { RDKFuncs.detectBondStereochemistry(mol, confId); }
public static ROMol DeleteSubstructs(ROMol mol, ROMol query, bool onlyFrags = false, bool useChirality = false) { return(RDKFuncs.deleteSubstructs(mol, query, onlyFrags, useChirality)); }
public static void CleanUp(RWMol mol) { RDKFuncs.cleanUp(mol); }
public static void AssignStereochemistry(ROMol mol, bool cleanIt = false, bool force = false, bool flagPossibleStereoCenters = false) { RDKFuncs.assignStereochemistry(mol, cleanIt, force, flagPossibleStereoCenters); }
public static void AssignChiralTypesFromBondDirs(ROMol mol, int confId = -1, bool replaceExistingTags = true) { RDKFuncs.assignChiralTypesFromBondDirs(mol, confId, replaceExistingTags); }
public static string MolToInchiKey(ROMol mol, string options = "") { return(RDKFuncs.MolToInchiKey(mol, options)); }
// // rdmolops // public static void AddHs(RWMol mol, bool explicitOnly = false, bool addCoords = false, UInt_Vect onlyOnAtoms = null, bool addResidueInfo = false) { RDKFuncs.addHs(mol, explicitOnly, addCoords, onlyOnAtoms, addResidueInfo); }
public static void AddRecursiveQueries(ROMol mol, StringMolMap queries, string propName) { RDKFuncs.addRecursiveQueries(mol, queries, propName); }