/// <summary> /// Calculates the eccentric connectivity /// </summary> /// <returns>A <see cref="Result"/> value representing the eccentric connectivity index</returns> public Result Calculate(IAtomContainer container) { container = AtomContainerManipulator.RemoveHydrogens(container); var natom = container.Atoms.Count; var admat = AdjacencyMatrix.GetMatrix(container); var distmat = PathTools.ComputeFloydAPSP(admat); int eccenindex = 0; for (int i = 0; i < natom; i++) { int max = -1; for (int j = 0; j < natom; j++) { if (distmat[i][j] > max) { max = distmat[i][j]; } } var degree = container.GetConnectedBonds(container.Atoms[i]).Count(); eccenindex += max * degree; } return(new Result(eccenindex)); }
/// <summary> /// Calculate the Wiener numbers. /// </summary> /// <returns>wiener numbers as array of 2 doubles</returns> public Result Calculate(IAtomContainer container) { // RemoveHydrogens does not break container var matr = ConnectionMatrix.GetMatrix(AtomContainerManipulator.RemoveHydrogens(container)); int wienerPathNumber = 0; //wienerPath int wienerPolarityNumber = 0; //wienerPol var distances = PathTools.ComputeFloydAPSP(matr); int partial; for (int i = 0; i < distances.Length; i++) { for (int j = 0; j < distances.Length; j++) { partial = distances[i][j]; wienerPathNumber += partial; if (partial == 3) { wienerPolarityNumber += 1; } } } return(new Result((double)wienerPathNumber / 2, (double)wienerPolarityNumber / 2)); }
/// <summary> /// This method calculate the ATS Autocorrelation descriptor. /// </summary> public Result Calculate(IAtomContainer container, int count = DefaultSize) { container = AtomContainerManipulator.RemoveHydrogens(container); var w = ListConvertion(container); var natom = container.Atoms.Count; var distancematrix = TopologicalMatrix.GetMatrix(container); var masSum = new double[count]; for (int k = 0; k < count; k++) { for (int i = 0; i < natom; i++) { for (int j = 0; j < natom; j++) { if (distancematrix[i][j] == k) { masSum[k] += w[i] * w[j]; } else { masSum[k] += 0; } } } if (k > 0) { masSum[k] = masSum[k] / 2; } } return(new Result(masSum)); }
public void TestLargeRingSystem() { var smiles = "O=C1Oc6ccccc6(C(O)C1C5c2ccccc2CC(c3ccc(cc3)c4ccccc4)C5)"; var smilesParser = CDK.SmilesParser; var molecule = smilesParser.ParseSmiles(smiles); DeduceBondSystemTool dbst = new DeduceBondSystemTool(new AllRingsFinder()); molecule = dbst.FixAromaticBondOrders(molecule); Assert.IsNotNull(molecule); molecule = (IAtomContainer)AtomContainerManipulator.RemoveHydrogens(molecule); Assert.AreEqual(34, molecule.Atoms.Count); // we should have 14 double bonds int doubleBondCount = 0; for (int i = 0; i < molecule.Bonds.Count; i++) { IBond bond = molecule.Bonds[i]; if (bond.Order == BondOrder.Double) { doubleBondCount++; } } Assert.AreEqual(13, doubleBondCount); }
[TestMethod(), Ignore()] // This is an example structure where this class fails public void TestLargeBioclipseUseCase() { var smiles = "COc1ccc2[C@@H]3[C@H](COc2c1)C(C)(C)OC4=C3C(=O)C(=O)C5=C4OC(C)(C)[C@@H]6COc7cc(OC)ccc7[C@H]56"; var smilesParser = CDK.SmilesParser; var molecule = smilesParser.ParseSmiles(smiles); DeduceBondSystemTool dbst = new DeduceBondSystemTool(new AllRingsFinder()); molecule = dbst.FixAromaticBondOrders(molecule); Assert.IsNotNull(molecule); molecule = (IAtomContainer)AtomContainerManipulator.RemoveHydrogens(molecule); Assert.AreEqual(40, molecule.Atoms.Count); // we should have 14 double bonds int doubleBondCount = 0; for (int i = 0; i < molecule.Bonds.Count; i++) { IBond bond = molecule.Bonds[i]; if (bond.Order == BondOrder.Double) { doubleBondCount++; } } Assert.AreEqual(10, doubleBondCount); }
public void TestPyrrole_Silent() { var smiles = "c2ccc3n([H])c1ccccc1c3(c2)"; var sp = new SmilesParser(builder, false); var molecule = sp.ParseSmiles(smiles); AtomContainerManipulator.SetSingleOrDoubleFlags(molecule); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule); molecule = dbst.FixAromaticBondOrders(molecule); Assert.IsNotNull(molecule); molecule = (IAtomContainer)AtomContainerManipulator.RemoveHydrogens(molecule); int doubleBondCount = 0; for (int i = 0; i < molecule.Bonds.Count; i++) { IBond bond = molecule.Bonds[i]; Assert.IsTrue(bond.IsAromatic); if (bond.Order == BondOrder.Double) { doubleBondCount++; } } Assert.AreEqual(6, doubleBondCount); }
public void TestPetitjeanNumberDescriptor() { var sp = CDK.SmilesParser; var mol = sp.ParseSmiles("O=C(O)CC"); AtomContainerManipulator.RemoveHydrogens(mol); Assert.AreEqual(0.33333334, CreateDescriptor().Calculate(mol).Value, 0.01); }
public Result Calculate(IAtomContainer container) { // we don't make a clone, since removeHydrogens returns a deep copy container = AtomContainerManipulator.RemoveHydrogens(container); 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); var subgraph3 = Order3(container); var subgraph4 = Order4(container); var subgraph5 = Order5(container); var subgraph6 = Order6(container); var subgraph7 = Order7(container); try { var order3s = ChiIndexUtils.EvalSimpleIndex(container, subgraph3); var order4s = ChiIndexUtils.EvalSimpleIndex(container, subgraph4); var order5s = ChiIndexUtils.EvalSimpleIndex(container, subgraph5); var order6s = ChiIndexUtils.EvalSimpleIndex(container, subgraph6); var order7s = ChiIndexUtils.EvalSimpleIndex(container, subgraph7); var order3v = ChiIndexUtils.EvalValenceIndex(container, subgraph3); var order4v = ChiIndexUtils.EvalValenceIndex(container, subgraph4); var order5v = ChiIndexUtils.EvalValenceIndex(container, subgraph5); var order6v = ChiIndexUtils.EvalValenceIndex(container, subgraph6); var order7v = ChiIndexUtils.EvalValenceIndex(container, subgraph7); return(new Result(new double[] { order3s, order4s, order5s, order6s, order7s, order3v, order4v, order5v, order6v, order7v, })); } catch (CDKException e) { return(new Result(e)); } }
public void TestKappaShapeIndicesDescriptor() { double[] testResult = { 5, 2.25, 4 }; var sp = CDK.SmilesParser; var mol = sp.ParseSmiles("O=C(O)CC"); AtomContainerManipulator.RemoveHydrogens(mol); var retval = CreateDescriptor().Calculate(mol).Values; Assert.AreEqual(testResult[2], retval[2], 0.0001); }
/// <summary> /// Evaluate the descriptor for the molecule. /// </summary> /// <returns>petitjean number</returns> public Result Calculate(IAtomContainer container) { container = AtomContainerManipulator.RemoveHydrogens(container); var diameter = PathTools.GetMolecularGraphDiameter(container); var radius = PathTools.GetMolecularGraphRadius(container); var petitjeanNumber = diameter == 0 ? 0 : (diameter - radius) / (double)diameter; return(new Result(petitjeanNumber)); }
public void TestWienerNumbersDescriptor() { double[] testResult = { 18, 2 }; var sp = CDK.SmilesParser; var mol = sp.ParseSmiles("[H]C([H])([H])C([H])([H])C(=O)O"); AtomContainerManipulator.RemoveHydrogens(mol); var retval = CreateDescriptor().Calculate(mol); Assert.AreEqual(testResult[0], retval.PathNumber, 0.0001); Assert.AreEqual(testResult[1], retval.PolarityNumber, 0.0001); }
public void TestWeightedPathDescriptor() { var sp = CDK.SmilesParser; { var mol = sp.ParseSmiles("CCCC"); var result = CreateDescriptor().Calculate(mol); var values = result.Values; Assert.AreEqual(6.871320, values[0], 0.000001); Assert.AreEqual(1.717830, values[1], 0.000001); Assert.AreEqual(0.0, values[2], 0.000001); Assert.AreEqual(0.0, values[3], 0.000001); Assert.AreEqual(0.0, values[4], 0.000001); } { var filename = "NCDK.Data.MDL.wpo.sdf"; IChemFile content; using (var reader = new MDLV2000Reader(ResourceLoader.GetAsStream(filename))) { content = reader.Read(CDK.Builder.NewChemFile()); } var cList = ChemFileManipulator.GetAllAtomContainers(content).ToReadOnlyList(); var mol = cList[0]; mol = AtomContainerManipulator.RemoveHydrogens(mol); var result = CreateDescriptor().Calculate(mol); var values = result.Values; Assert.AreEqual(18.42026, values[0], 0.00001); Assert.AreEqual(1.842026, values[1], 0.00001); Assert.AreEqual(13.45733, values[2], 0.00001); Assert.AreEqual(13.45733, values[3], 0.00001); Assert.AreEqual(0, values[4], 0.00001); } { var filename = "NCDK.Data.MDL.wpn.sdf"; IChemFile content; using (var reader = new MDLV2000Reader(ResourceLoader.GetAsStream(filename))) { content = reader.Read(CDK.Builder.NewChemFile()); } var cList = ChemFileManipulator.GetAllAtomContainers(content).ToReadOnlyList(); var mol = cList[0]; mol = AtomContainerManipulator.RemoveHydrogens(mol); var result = CreateDescriptor().Calculate(mol); var values = result.Values; Assert.AreEqual(26.14844, values[0], 0.00001); Assert.AreEqual(1.867746, values[1], 0.00001); Assert.AreEqual(19.02049, values[2], 0.00001); Assert.AreEqual(0, values[3], 0.000001); Assert.AreEqual(19.02049, values[4], 0.00001); } }
/// <summary> /// This method calculates occurrences of the Kier & Hall E-state fragments. /// </summary> /// <returns>Counts of the fragments</returns> public Result Calculate(IAtomContainer container) { container = AtomContainerManipulator.RemoveHydrogens(container); var counts = new int[SMARTS.Count]; SmartsPattern.Prepare(container); for (int i = 0; i < SMARTS.Count; i++) { counts[i] = SMARTS[i].MatchAll(container).CountUnique(); } return(new Result(counts)); }
public Result Calculate(IAtomContainer container, int count = DefaultSize) { container = (IAtomContainer)container.Clone(); container = AtomContainerManipulator.RemoveHydrogens(container); try { var w = Listcharges(container); var natom = container.Atoms.Count; var distancematrix = TopologicalMatrix.GetMatrix(container); var chargeSum = new double[count]; for (int k = 0; k < count; k++) { for (int i = 0; i < natom; i++) { for (int j = 0; j < natom; j++) { if (distancematrix[i][j] == k) { chargeSum[k] += w[i] * w[j]; } else { chargeSum[k] += 0; } } } if (k > 0) { chargeSum[k] = chargeSum[k] / 2; } } return(new Result(chargeSum)); } catch (CDKException e) { return(new Result(e)); } }
/// <summary> /// Calculates the weighted path descriptors. /// </summary> /// <returns>A value representing the weighted path values</returns> public Result Calculate(IAtomContainer container) { container = AtomContainerManipulator.RemoveHydrogens(container); int natom = container.Atoms.Count; var retval = new List <double>(5); var pathList = new List <IList <IAtom> >(); // unique paths for (int i = 0; i < natom - 1; i++) { var a = container.Atoms[i]; for (int j = i + 1; j < natom; j++) { var b = container.Atoms[j]; pathList.AddRange(PathTools.GetAllPaths(container, a, b)); } } // heteroatoms var pathWts = GetPathWeights(pathList, container); double mid = 0.0; foreach (var pathWt3 in pathWts) { mid += pathWt3; } mid += natom; // since we don't calculate paths of length 0 above retval.Add(mid); retval.Add(mid / (double)natom); pathList.Clear(); int count = 0; for (int i = 0; i < natom; i++) { var a = container.Atoms[i]; if (a.AtomicNumber.Equals(AtomicNumbers.C)) { continue; } count++; for (int j = 0; j < natom; j++) { var b = container.Atoms[j]; if (a.Equals(b)) { continue; } pathList.AddRange(PathTools.GetAllPaths(container, a, b)); } } pathWts = GetPathWeights(pathList, container); mid = 0.0; foreach (var pathWt2 in pathWts) { mid += pathWt2; } mid += count; retval.Add(mid); // oxygens pathList.Clear(); count = 0; for (int i = 0; i < natom; i++) { var a = container.Atoms[i]; if (!a.AtomicNumber.Equals(AtomicNumbers.O)) { continue; } count++; for (int j = 0; j < natom; j++) { var b = container.Atoms[j]; if (a.Equals(b)) { continue; } pathList.AddRange(PathTools.GetAllPaths(container, a, b)); } } pathWts = GetPathWeights(pathList, container); mid = 0.0; foreach (var pathWt1 in pathWts) { mid += pathWt1; } mid += count; retval.Add(mid); // nitrogens pathList.Clear(); count = 0; for (int i = 0; i < natom; i++) { var a = container.Atoms[i]; if (!a.AtomicNumber.Equals(AtomicNumbers.N)) { continue; } count++; for (int j = 0; j < natom; j++) { var b = container.Atoms[j]; if (a.Equals(b)) { continue; } pathList.AddRange(PathTools.GetAllPaths(container, a, b)); } } pathWts = GetPathWeights(pathList, container); mid = 0.0; foreach (var pathWt in pathWts) { mid += pathWt; } mid += count; retval.Add(mid); return(new Result(retval)); }
/// <summary> /// Calculates the kier shape indices for an atom container /// </summary> /// <returns>kier1, kier2 and kier3 are returned as arrayList of doubles</returns> public Result Calculate(IAtomContainer container) { container = (IAtomContainer)container.Clone(); container = AtomContainerManipulator.RemoveHydrogens(container); var singlePaths = new List <double>(); var doublePaths = new List <string>(); var triplePaths = new List <string>(); foreach (var atom1 in container.Atoms) { var firstAtomNeighboors = container.GetConnectedAtoms(atom1); foreach (var firstAtomNeighboor in firstAtomNeighboors) { var bond1 = container.Bonds.IndexOf(container.GetBond(atom1, firstAtomNeighboor)); if (!singlePaths.Contains(bond1)) { singlePaths.Add(bond1); singlePaths.Sort(); } var secondAtomNeighboors = container.GetConnectedAtoms(firstAtomNeighboor); foreach (var secondAtomNeighboor in secondAtomNeighboors) { var bond2 = container.Bonds.IndexOf(container.GetBond(firstAtomNeighboor, secondAtomNeighboor)); if (!singlePaths.Contains(bond2)) { singlePaths.Add(bond2); } var sorterFirst = new double[] { bond1, bond2 }; Array.Sort(sorterFirst); var tmpbond2 = sorterFirst[0] + "+" + sorterFirst[1]; if (!doublePaths.Contains(tmpbond2) && (bond1 != bond2)) { doublePaths.Add(tmpbond2); } var thirdAtomNeighboors = container.GetConnectedAtoms(secondAtomNeighboor); foreach (var thirdAtomNeighboor in thirdAtomNeighboors) { var bond3 = container.Bonds.IndexOf(container.GetBond(secondAtomNeighboor, thirdAtomNeighboor)); if (!singlePaths.Contains(bond3)) { singlePaths.Add(bond3); } var sorterSecond = new double[] { bond1, bond2, bond3 }; Array.Sort(sorterSecond); var tmpbond3 = sorterSecond[0] + "+" + sorterSecond[1] + "+" + sorterSecond[2]; if (!triplePaths.Contains(tmpbond3)) { if ((bond1 != bond2) && (bond1 != bond3) && (bond2 != bond3)) { triplePaths.Add(tmpbond3); } } } } } } var kier = new double[] { 0, 0, 0, }; do { if (container.Atoms.Count == 1) { break; } kier[0] = (double)(container.Atoms.Count * (container.Atoms.Count - 1) * (container.Atoms.Count - 1)) / (singlePaths.Count * singlePaths.Count); if (container.Atoms.Count == 2) { break; } kier[1] = doublePaths.Count == 0 ? double.NaN : (double)((container.Atoms.Count - 1) * (container.Atoms.Count - 2) * (container.Atoms.Count - 2)) / (doublePaths.Count * doublePaths.Count); if (container.Atoms.Count == 3) { break; } kier[2] = triplePaths.Count == 0 ? double.NaN : ( container.Atoms.Count % 2 != 0 ? (double)((container.Atoms.Count - 1) * (container.Atoms.Count - 3) * (container.Atoms.Count - 3)) / (triplePaths.Count * triplePaths.Count) : (double)((container.Atoms.Count - 3) * (container.Atoms.Count - 2) * (container.Atoms.Count - 2)) / (triplePaths.Count * triplePaths.Count) ); } while (false); return(new Result(kier)); }
public Calculator(IAtomContainer container) { this.container = AtomContainerManipulator.RemoveHydrogens(container); // it returns clone adjMatrix = AdjacencyMatrix.GetMatrix(container); tdist = PathTools.ComputeFloydAPSP(adjMatrix); }
public static double[][] EvalMatrix(IAtomContainer atomContainer, double[] vsd) { IAtomContainer local = AtomContainerManipulator.RemoveHydrogens(atomContainer); int natom = local.Atoms.Count; double[][] matrix = Arrays.CreateJagged <double>(natom, natom); for (int i = 0; i < natom; i++) { for (int j = 0; j < natom; j++) { matrix[i][j] = 0.0; } } /* set the off diagonal entries */ for (int i = 0; i < natom - 1; i++) { for (int j = i + 1; j < natom; j++) { for (int k = 0; k < local.Bonds.Count; k++) { var bond = local.Bonds[k]; if (bond.Contains(local.Atoms[i]) && bond.Contains(local.Atoms[j])) { if (bond.IsAromatic) { matrix[i][j] = 0.15; } else if (bond.Order == BondOrder.Single) { matrix[i][j] = 0.1; } else if (bond.Order == BondOrder.Double) { matrix[i][j] = 0.2; } else if (bond.Order == BondOrder.Triple) { matrix[i][j] = 0.3; } if (local.GetConnectedBonds(local.Atoms[i]).Count() == 1 || local.GetConnectedBonds(local.Atoms[j]).Count() == 1) { matrix[i][j] += 0.01; } matrix[j][i] = matrix[i][j]; } else { matrix[i][j] = 0.001; matrix[j][i] = 0.001; } } } } /* set the diagonal entries */ for (int i = 0; i < natom; i++) { if (vsd != null) { matrix[i][i] = vsd[i]; } else { matrix[i][i] = 0.0; } } return(matrix); }
/// <summary> /// Calculates the two Petitjean shape indices. /// </summary> /// <returns>A <see cref="ResolveEventArgs"/> representing the Petitjean shape indices</returns> public Result Calculate(IAtomContainer container) { var local = AtomContainerManipulator.RemoveHydrogens(container); var tradius = PathTools.GetMolecularGraphRadius(local); var tdiameter = PathTools.GetMolecularGraphDiameter(local); var topoShape = (double)(tdiameter - tradius) / tradius; var geomShape = double.NaN; // get the 3D distance matrix if (GeometryUtil.Has3DCoordinates(container)) { var natom = container.Atoms.Count; var distanceMatrix = Arrays.CreateJagged <double>(natom, natom); for (int i = 0; i < natom; i++) { for (int j = 0; j < natom; j++) { if (i == j) { distanceMatrix[i][j] = 0.0; continue; } var a = container.Atoms[i].Point3D.Value; var b = container.Atoms[j].Point3D.Value; distanceMatrix[i][j] = Math.Sqrt((a.X - b.X) * (a.X - b.X) + (a.Y - b.Y) * (a.Y - b.Y) + (a.Z - b.Z) * (a.Z - b.Z)); } } double gradius = 999999; double gdiameter = -999999; var geta = new double[natom]; for (int i = 0; i < natom; i++) { double max = -99999; for (int j = 0; j < natom; j++) { if (distanceMatrix[i][j] > max) { max = distanceMatrix[i][j]; } } geta[i] = max; } for (int i = 0; i < natom; i++) { if (geta[i] < gradius) { gradius = geta[i]; } if (geta[i] > gdiameter) { gdiameter = geta[i]; } } geomShape = (gdiameter - gradius) / gradius; } return(new Result(topoShape, geomShape)); }