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);
}
