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