/// <summary>
/// Returns the topological matrix for the given AtomContainer.
/// </summary>
/// <param name="container">The AtomContainer for which the matrix is calculated</param>
/// <returns>A topological matrix representating this AtomContainer</returns>
public static int[][] GetMatrix(IAtomContainer container)
{
int[][] conMat = AdjacencyMatrix.GetMatrix(container);
int[][] topolDistance = PathTools.ComputeFloydAPSP(conMat);
return(topolDistance);
}
/// <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>
/// Returns the diameter of the molecular graph.
/// </summary>
/// <param name="atomContainer">The molecule to consider</param>
/// <returns>The topological diameter</returns>
public static int GetMolecularGraphDiameter(IAtomContainer atomContainer)
{
int natom = atomContainer.Atoms.Count;
int[][] admat = AdjacencyMatrix.GetMatrix(atomContainer);
int[][] distanceMatrix = ComputeFloydAPSP(admat);
int[] eta = new int[natom];
for (int i = 0; i < natom; i++)
{
int mmax = -99999;
for (int j = 0; j < natom; j++)
{
if (distanceMatrix[i][j] > mmax)
{
mmax = distanceMatrix[i][j];
}
}
eta[i] = mmax;
}
int max = -999999;
foreach (var anEta in eta)
{
if (anEta > max)
{
max = anEta;
}
}
return(max);
}
/// <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));
}
/// <summary>
/// Returns the number of vertices that are a distance 'd' apart.
/// <para>In this method, d is the topological distance (i.e. edge count).</para>
/// </summary>
/// <param name="atomContainer">The molecule to consider</param>
/// <param name="distance">The distance to consider</param>
/// <returns>The number of vertices</returns>
public static int GetVertexCountAtDistance(IAtomContainer atomContainer, int distance)
{
int natom = atomContainer.Atoms.Count;
int[][] admat = AdjacencyMatrix.GetMatrix(atomContainer);
int[][] distanceMatrix = ComputeFloydAPSP(admat);
int matches = 0;
for (int i = 0; i < natom; i++)
{
for (int j = 0; j < natom; j++)
{
if (distanceMatrix[i][j] == distance)
{
matches++;
}
}
}
return(matches / 2);
}
private static Result CalculateMain(IAtomContainer container, int nhigh, int nlow)
{
var iso = CDK.IsotopeFactory;
int nheavy = 0;
// find number of heavy atoms
nheavy += container.Atoms.Count(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H));
if (nheavy == 0)
{
throw new CDKException("No heavy atoms in the container");
}
var diagvalue = new double[nheavy];
// get atomic mass weighted BCUT
try
{
var counter = 0;
foreach (var atom in container.Atoms.Where(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H)))
{
diagvalue[counter] = iso.GetMajorIsotope(atom.AtomicNumber).ExactMass.Value;
counter++;
}
}
catch (Exception e)
{
throw new CDKException($"Could not calculate weight: {e.Message}", e);
}
double[] eval1, eval2, eval3;
{
var burdenMatrix = BurdenMatrix.EvalMatrix(container, diagvalue);
if (HasUndefined(burdenMatrix))
{
throw new CDKException("Burden matrix has undefined values");
}
var matrix = Matrix <double> .Build.DenseOfColumnArrays(burdenMatrix);
var eigenDecomposition = matrix.Evd().EigenValues;
eval1 = eigenDecomposition.Select(n => n.Real).ToArray();
}
try
{
// get charge weighted BCUT
CDK.LonePairElectronChecker.Saturate(container);
var charges = new double[container.Atoms.Count];
var peoe = new GasteigerMarsiliPartialCharges();
peoe.AssignGasteigerMarsiliSigmaPartialCharges(container, true);
for (int i = 0; i < container.Atoms.Count; i++)
{
charges[i] += container.Atoms[i].Charge.Value;
}
for (int i = 0; i < container.Atoms.Count; i++)
{
container.Atoms[i].Charge = charges[i];
}
}
catch (Exception e)
{
throw new CDKException("Could not calculate partial charges: " + e.Message, e);
}
{
var counter = 0;
foreach (var atom in container.Atoms.Where(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H)))
{
diagvalue[counter++] = atom.Charge.Value;
}
}
{
var burdenMatrix = BurdenMatrix.EvalMatrix(container, diagvalue);
if (HasUndefined(burdenMatrix))
{
throw new CDKException("Burden matrix has undefined values");
}
var matrix = Matrix <double> .Build.DenseOfColumnArrays(burdenMatrix);
var eigenDecomposition = matrix.Evd().EigenValues;
eval2 = eigenDecomposition.Select(n => n.Real).ToArray();
}
var topoDistance = PathTools.ComputeFloydAPSP(AdjacencyMatrix.GetMatrix(container));
// get polarizability weighted BCUT
{
var counter = 0;
foreach (var atom in container.Atoms.Where(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H)))
{
diagvalue[counter++] = Polarizability.CalculateGHEffectiveAtomPolarizability(container, atom, false, topoDistance);
}
}
{
var burdenMatrix = BurdenMatrix.EvalMatrix(container, diagvalue);
if (HasUndefined(burdenMatrix))
{
throw new CDKException("Burden matrix has undefined values");
}
var matrix = Matrix <double> .Build.DenseOfColumnArrays(burdenMatrix);
var eigenDecomposition = matrix.Evd().EigenValues;
eval3 = eigenDecomposition.Select(n => n.Real).ToArray();
}
// return only the n highest & lowest eigenvalues
int lnlow, lnhigh, enlow, enhigh;
if (nlow > nheavy)
{
lnlow = nheavy;
enlow = nlow - nheavy;
}
else
{
lnlow = nlow;
enlow = 0;
}
if (nhigh > nheavy)
{
lnhigh = nheavy;
enhigh = nhigh - nheavy;
}
else
{
lnhigh = nhigh;
enhigh = 0;
}
var retval = new List <double>((lnlow + enlow + lnhigh + enhigh) * 3);
for (int i = 0; i < lnlow; i++)
{
retval.Add(eval1[i]);
}
for (int i = 0; i < enlow; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnhigh; i++)
{
retval.Add(eval1[eval1.Length - i - 1]);
}
for (int i = 0; i < enhigh; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnlow; i++)
{
retval.Add(eval2[i]);
}
for (int i = 0; i < enlow; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnhigh; i++)
{
retval.Add(eval2[eval2.Length - i - 1]);
}
for (int i = 0; i < enhigh; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnlow; i++)
{
retval.Add(eval3[i]);
}
for (int i = 0; i < enlow; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnhigh; i++)
{
retval.Add(eval3[eval3.Length - i - 1]);
}
for (int i = 0; i < enhigh; i++)
{
retval.Add(double.NaN);
}
return(new Result(retval, nhigh, nlow));
}
public Calculator(IAtomContainer container)
{
this.container = AtomContainerManipulator.RemoveHydrogens(container); // it returns clone
adjMatrix = AdjacencyMatrix.GetMatrix(container);
tdist = PathTools.ComputeFloydAPSP(adjMatrix);
}
