public void TestBug1701073() { string[] smiles = new string[] { "C1CCCC=2[C]1(C(=O)NN2)C", "C1CCCC=2[C]1(C(=O)NN2)O", "C[Si](C)(C)[CH](Br)CC(F)(Br)F", "c1(ccc(cc1)O)C#N", "CCN(CC)C#CC#CC(=O)OC", "C(#CN1CCCCC1)[Sn](C)(C)C", "c1([As+](c2ccccc2)(c2ccccc2)C)ccccc1.[I-]", "c1(noc(n1)CCC(=O)N(CC)CC)c1ccc(cc1)C", "c1c(c(ccc1)O)/C=N/CCCC", "c1(ccc(cc1)C#Cc1ccc(cc1)C#C)OC", }; var sp = CDK.SmilesParser; foreach (var smile in smiles) { var mol = sp.ParseSmiles(smile); AddImplicitHydrogens(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); var descriptor = CreateDescriptor(mol); foreach (var atom in mol.Atoms) { var dummy = descriptor.Calculate(atom).Value; } } }
public void TestFingerprint() { IFingerprinter printer = new PubchemFingerprinter(); var adder = CDK.HydrogenAdder; var mol1 = parser.ParseSmiles("c1ccccc1CCc1ccccc1"); var mol2 = parser.ParseSmiles("c1ccccc1CC"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol1); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol2); adder.AddImplicitHydrogens(mol1); adder.AddImplicitHydrogens(mol2); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol1); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol2); Aromaticity.CDKLegacy.Apply(mol1); Aromaticity.CDKLegacy.Apply(mol2); BitArray bs1 = printer.GetBitFingerprint(mol1).AsBitSet(); BitArray bs2 = printer.GetBitFingerprint(mol2).AsBitSet(); Assert.AreEqual(881, printer.Length); Assert.IsFalse(FingerprinterTool.IsSubset(bs1, bs2), "c1ccccc1CC was detected as a subset of c1ccccc1CCc1ccccc1"); }
private IAtomContainer LoadSmi(string smi) { var mol = smipar.ParseSmiles(smi); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); return(mol); }
public static IAtomContainer ParseSmiles(string smiles) { var molecule = CDK.SmilesParser.ParseSmiles(smiles); AtomContainerManipulator.PercieveAtomTypesAndConfigureUnsetProperties(molecule); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(molecule); Aromaticity.CDKLegacy.Apply(molecule); return(molecule); }
// check if the first atom of the container is accepted static void Test(IAtomContainer container, CoordinateType type, string mesg, bool hnorm) { Assert.AreEqual(type, Stereocenters.Of(container).ElementType(0), mesg); if (hnorm) { AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); Assert.AreEqual(type, Stereocenters.Of(container).ElementType(0), mesg + " (unsupressed hydrogens)"); } }
/// <summary> /// Given a structure in the correct configuration (explicit H and aromatised) it will return the logP as a Double /// or if it is out of domain (encounters an unknown atomtype) it will return <see cref="Double.NaN"/>. /// </summary> /// <param name="container">the structure to calculate which have explicit H and be aromatised.</param> /// <returns>The calculated logP</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); Aromaticity.CDKLegacy.Apply(container); return(new JPlogPCalculator(container, coeffs).Calculate()); }
public void TestEthaneIncludeTerminalsExplicitH() { var container = MakeEthane(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); var result = CreateDescriptor().Calculate(container, true, false); Assert.AreEqual(1, result.Value); }
/// <summary> /// This method calculate the ATS Autocorrelation descriptor. /// </summary> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); Aromaticity.CDKLegacy.Apply(container); // get the distance matrix for pol calcs as well as for later on var distancematrix = PathTools.ComputeFloydAPSP(AdjacencyMatrix.GetMatrix(container)); var w = Listpolarizability(container, distancematrix); var natom = container.Atoms.Count; var polarizabilitySum = new double[5]; for (int k = 0; k < 5; k++) { for (int i = 0; i < natom; i++) { if (container.Atoms[i].AtomicNumber.Equals(AtomicNumbers.H)) { continue; } for (int j = 0; j < natom; j++) { if (container.Atoms[j].AtomicNumber.Equals(AtomicNumbers.H)) { continue; } if (distancematrix[i][j] == k) { polarizabilitySum[k] += w[i] * w[j]; } else { polarizabilitySum[k] += 0.0; } } } if (k > 0) { polarizabilitySum[k] = polarizabilitySum[k] / 2; } } return(new Result(polarizabilitySum)); }
public void TestCID25181289() { var mol = parser.ParseSmiles("C=C(C1=CC=C(C=C1)O)NNC2=C(C(=NC(=C2Cl)Cl)C(=O)O)Cl"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); Aromaticity.CDKLegacy.Apply(mol); IFingerprinter printer = new PubchemFingerprinter(); BitArray fp = printer.GetBitFingerprint(mol).AsBitSet(); BitArray ref_ = PubchemFingerprinter .Decode("AAADccBzMAAGAAAAAAAAAAAAAAAAAAAAAAA8QAAAAAAAAAABwAAAHgIYCAAADA6BniAwzpJqEgCoAyTyTASChCAnJiIYumGmTtgKJnLD1/PEdQhkwBHY3Qe82AAOIAAAAAAAAABAAAAAAAAAAAAAAAAAAA=="); Assert.IsTrue(BitArrays.Equals(ref_, fp)); }
public void TestCID5934166() { var mol = parser.ParseSmiles("C1=CC=C(C=C1)C[N+]2=C(C=C(C=C2C=CC3=CC=CC=C3)C4=CC=CC=C4)C5=CC=CC=C5"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); Aromaticity.CDKLegacy.Apply(mol); IFingerprinter printer = new PubchemFingerprinter(); BitArray fp = printer.GetBitFingerprint(mol).AsBitSet(); BitArray ref_ = PubchemFingerprinter .Decode("AAADceB+AAAAAAAAAAAAAAAAAAAAAAAAAAA8YMGCAAAAAAAB1AAAHAAAAAAADAjBHgQwgJMMEACgAyRiRACCgCAhAiAI2CA4ZJgIIOLAkZGEIAhggADIyAcQgMAOgAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); Assert.IsTrue(BitArrays.Equals(ref_, fp)); }
public void TestCID2518130() { var mol = parser.ParseSmiles("COC1C(C(C(C(O1)CO)OC2C(C(C(C(O2)CO)S)O)O)O)O"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); Aromaticity.CDKLegacy.Apply(mol); IFingerprinter printer = new PubchemFingerprinter(); BitArray fp = printer.GetBitFingerprint(mol).AsBitSet(); BitArray ref_ = PubchemFingerprinter .Decode("AAADceBwPABAAAAAAAAAAAAAAAAAAAAAAAAkSAAAAAAAAAAAAAAAGgQACAAACBS0wAOCCAAABgQAAAAAAAAAAAAAAAAAAAAAAAAREAIAAAAiQAAFAAAHAAHAYAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); Assert.IsTrue(BitArrays.Equals(ref_, fp)); }
public void TestBenzene() { var mol = parser.ParseSmiles("c1ccccc1"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); Aromaticity.CDKLegacy.Apply(mol); IFingerprinter printer = new PubchemFingerprinter(); BitArray fp = printer.GetBitFingerprint(mol).AsBitSet(); BitArray ref_ = PubchemFingerprinter .Decode("AAADcYBgAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAAAAAAABAAAAGAAAAAAACACAEAAwAIAAAACAACBCAAACAAAgAAAIiAAAAIgIICKAERCAIAAggAAIiAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=="); Assert.IsTrue(BitArrays.Equals(ref_, fp)); }
public void TestBenzeneFromSmiles() { var sp = CDK.SmilesParser; mol = sp.ParseSmiles("C1=CC=CC=C1"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); Aromaticity.CDKLegacy.Apply(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); matcher.RingSet = GetRings(); foreach (var atom in mol.Atoms) { if (atom.Symbol.Equals("C")) { Assert.IsTrue(TestAtom("SaaCH", atom)); } } }
public static void Script8_3() { var parser = new SmilesParser(); var hAdder = CDKHydrogenAdder.GetInstance(); var methanol = parser.ParseSmiles("CO"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(methanol); hAdder.AddImplicitHydrogens(methanol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(methanol); var dimethoxymethane = parser.ParseSmiles("COC"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(dimethoxymethane); hAdder.AddImplicitHydrogens(dimethoxymethane); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(dimethoxymethane); var water = parser.ParseSmiles("O"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(water); hAdder.AddImplicitHydrogens(water); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(water); var reaction = new Reaction(); reaction.Reactants.Add(methanol, 2.0D); reaction.Products.Add(dimethoxymethane); reaction.Products.Add(water); Console.WriteLine("Reactants:"); foreach (var reactant in reaction.Reactants) { var formula = MolecularFormulaManipulator.GetMolecularFormula(reactant); Console.WriteLine(MolecularFormulaManipulator.GetString(formula)); } Console.WriteLine("Products: "); foreach (var product in reaction.Products) { var formula = MolecularFormulaManipulator.GetMolecularFormula(product); Console.WriteLine(MolecularFormulaManipulator.GetString(formula)); } }
public void TestGetFingerprintAsBytes() { var mol = parser.ParseSmiles("C=C(C1=CC=C(C=C1)O)NNC2=C(C(=NC(=C2Cl)Cl)C(=O)O)Cl"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(mol); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol); Aromaticity.CDKLegacy.Apply(mol); PubchemFingerprinter printer = new PubchemFingerprinter(); BitArray fp = printer.GetBitFingerprint(mol).AsBitSet(); byte[] actual = printer.GetFingerprintAsBytes(); byte[] expected = Arrays.CopyOf(ToByteArray(fp), actual.Length); Assert.IsTrue(Compares.AreEqual(expected, actual)); }
public void Ctor() { #region SmilesParser sp = new SmilesParser(); IAtomContainer ac = sp.ParseSmiles("CC"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(ac); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(ac); MMFF94PartialCharges mmff = new MMFF94PartialCharges(); mmff.AssignMMFF94PartialCharges(ac); #endregion foreach (var atom in ac.Atoms) { Console.WriteLine( #region result atom.GetProperty <double>("MMFF94charge") #endregion ); } }
private static void AddExplicitHydrogens(IAtomContainer container) { try { var matcher = CDK.AtomTypeMatcher; foreach (var atom in container.Atoms) { var type = matcher.FindMatchingAtomType(container, atom); AtomTypeManipulator.Configure(atom, type); } var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); } catch (Exception) { Debug.WriteLine("Error in hydrogen addition"); } }
public void TestMultithReadedUsage() { var mol1 = parser.ParseSmiles("C=C(C1=CC=C(C=C1)O)NNC2=C(C(=NC(=C2Cl)Cl)C(=O)O)Cl"); IAtomContainer mol2 = parser .ParseSmiles("C1=CC=C(C=C1)C[N+]2=C(C=C(C=C2C=CC3=CC=CC=C3)C4=CC=CC=C4)C5=CC=CC=C5"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol1); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol2); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(mol1); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol1); Aromaticity.CDKLegacy.Apply(mol1); adder.AddImplicitHydrogens(mol2); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(mol2); Aromaticity.CDKLegacy.Apply(mol2); IFingerprinter fp = new PubchemFingerprinter(); BitArray bs1 = fp.GetBitFingerprint(mol1).AsBitSet(); BitArray bs2 = fp.GetBitFingerprint(mol2).AsBitSet(); // now lets run some threads var objs = new List <FpRunner> { new FpRunner(mol1), new FpRunner(mol2) }; var ret = Parallel.ForEach(objs, o => o.Call()); Assert.IsTrue(ret.IsCompleted); BitArray fb1 = objs[0].Result; Assert.IsNotNull(fb1); BitArray fb2 = objs[1].Result; Assert.IsNotNull(fb2); Assert.IsTrue(BitArrays.Equals(bs1, fb1)); Assert.IsTrue(BitArrays.Equals(bs2, fb2)); }
public void TestUITTimeoutFix() { // Load molecules var filename = "NCDK.Data.MDL.UITTimeout.sdf"; var ins = ResourceLoader.GetAsStream(filename); var reader = new MDLV2000Reader(ins); var content = reader.Read(builder.NewChemFile()); var cList = ChemFileManipulator.GetAllAtomContainers(content).ToReadOnlyList(); var molecules = new IAtomContainer[2]; for (int j = 0; j < 2; j++) { var aAtomContainer = cList[j]; var tmpMatcher = CDK.AtomTypeMatcher; var tmpAdder = CDK.HydrogenAdder; for (int i = 0; i < aAtomContainer.Atoms.Count; i++) { var tmpAtom = aAtomContainer.Atoms[i]; var tmpType = tmpMatcher.FindMatchingAtomType(aAtomContainer, tmpAtom); AtomTypeManipulator.Configure(tmpAtom, tmpType); tmpAdder.AddImplicitHydrogens(aAtomContainer, tmpAtom); } AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(aAtomContainer); molecules[j] = aAtomContainer; } var query = QueryAtomContainerCreator.CreateAnyAtomForPseudoAtomQueryContainer(molecules[1]); // test var starttime = System.DateTime.Now.Ticks; uiTester.Timeout = 200; uiTester.GetSubgraphAtomsMaps(molecules[0], query); var duration = System.DateTime.Now.Ticks - starttime; // The search must last much longer then two seconds if the timeout not works Assert.IsTrue(duration < 2000 * 10000); // 1 msec = 10000 ticks }
/// <summary> /// Calculates the three classes of BCUT descriptors. /// </summary> /// <returns>An ArrayList containing the descriptors. The default is to return /// all calculated eigenvalues of the Burden matrices in the order described /// above. If a parameter list was supplied, then only the specified number /// of highest and lowest eigenvalues (for each class of BCUT) will be returned. /// </returns> /// <param name="nhigh">The number of highest eigenvalue</param> /// <param name="nlow">The number of lowest eigenvalue</param> public Result Calculate(IAtomContainer container, int nhigh = 1, int nlow = 1) { container = (IAtomContainer)container.Clone(); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); if (checkAromaticity) { AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container); Aromaticity.CDKLegacy.Apply(container); } try { return(CalculateMain(container, nhigh, nlow)); } catch (CDKException e) { return(new Result(e)); } }
public void TestBiphenyl() { //get the biphenyl as aromatic smiles var parser = CDK.SmilesParser; var biphenyl_aromaticsmiles = parser.ParseSmiles("c1ccccc1-c2ccccc2"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(biphenyl_aromaticsmiles); var hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(biphenyl_aromaticsmiles); Aromaticity.CDKLegacy.Apply(biphenyl_aromaticsmiles); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(biphenyl_aromaticsmiles); //get the biphenyl as Kekule smiles var biphenyl_kekulesmiles = parser.ParseSmiles("C1=C(C=CC=C1)C2=CC=CC=C2"); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(biphenyl_kekulesmiles); hAdder = CDK.HydrogenAdder; hAdder.AddImplicitHydrogens(biphenyl_kekulesmiles); Aromaticity.CDKLegacy.Apply(biphenyl_kekulesmiles); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(biphenyl_kekulesmiles); Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(biphenyl_aromaticsmiles, biphenyl_kekulesmiles)); }
/// <summary> /// Convenience method that perceives atom types (CDK scheme) and /// adds explicit hydrogens accordingly. It does not create 2D or 3D /// coordinates for the new hydrogens. /// </summary> /// <param name="container">to which explicit hydrogens are added.</param> protected void AddExplicitHydrogens(IAtomContainer container) { AddImplicitHydrogens(container); AtomContainerManipulator.ConvertImplicitToExplicitHydrogens(container); }