/**
* Calculates the eccentric connectivity
*
* @param container Parameter is the atom container.
* @return An IntegerResult value representing the eccentric connectivity index
*/
@TestMethod("testCalculate_IAtomContainer")
public DescriptorValue calculate(IAtomContainer container) {
IAtomContainer local = AtomContainerManipulator.removeHydrogens(container);
int natom = local.getAtomCount();
int[][] admat = AdjacencyMatrix.getMatrix(local);
int[][] 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];
}
int degree = local.getConnectedBondsCount(i);
eccenindex += max * degree;
}
IntegerResult retval = new IntegerResult(eccenindex);
return new DescriptorValue(
getSpecification(),
getParameterNames(),
getParameters(),
retval,
getDescriptorNames(),
null);
}
/**
* Performs a breadthFirstSearch in an AtomContainer starting with a particular sphere, which
* usually consists of one start atom, and searches for a pi system.
*
* @param container The AtomContainer to be searched
* @param sphere A sphere of atoms to start the search with
* @param path A ArrayList which stores the atoms belonging to the pi system
* @throws org.openscience.cdk.exception.CDKException Description of the Exception
*/
private void breadthFirstSearch(IAtomContainer container, List<IAtom> sphere, List<IAtom> path)
throws CDKException {
IAtom atom;
IAtom nextAtom;
List<IAtom> newSphere = new ArrayList<IAtom>();
// logger.debug("Start of breadthFirstSearch");
for (int i = 0; i < sphere.size(); i++) {
atom = sphere.get(i);
// logger.debug("BreadthFirstSearch around atom " + (atomNr + 1));
List<IBond> bonds = container.getConnectedBondsList(atom);
for (IBond bond : bonds) {
nextAtom = bond.getConnectedAtom(atom);
if ((!nextAtom.getFlag(CDKConstants.ISAROMATIC) && !nextAtom.getFlag(CDKConstants.ISINRING))
& !nextAtom.getFlag(CDKConstants.VISITED)) {
// logger.debug("BDS> AtomNr:"+container.getAtomNumber(nextAtom)+"
// maxBondOrder:"+container.getMaximumBondOrder(nextAtom)+"
// Aromatic:"+nextAtom.getFlag(CDKConstants.ISAROMATIC)+"
// FormalCharge:"+nextAtom.getFormalCharge()+" Charge:"+nextAtom.getCharge()+"
// Flag:"+nextAtom.getFlag(CDKConstants.VISITED));
path.add(nextAtom);
// logger.debug("BreadthFirstSearch is meeting new atom " + (nextAtomNr + 1));
nextAtom.setFlag(CDKConstants.VISITED, true);
if (container.getConnectedBondsCount(nextAtom) > 1) {
newSphere.add(nextAtom);
}
} else {
nextAtom.setFlag(CDKConstants.VISITED, true);
}
}
}
if (newSphere.size() > 0) {
breadthFirstSearch(container, newSphere, path);
}
}
private boolean isChemicallyValid(IAtomContainer union) throws CDKException {
for (IAtom atom : union.atoms()) {
if ((union.getConnectedBondsCount(atom) + atom.getFormalCharge())
> atom.getFormalNeighbourCount()) {
return false;
}
}
return true;
}
/**
* Finds the Smallest Set of Smallest Rings.
*
* @param mol the molecule to be searched for rings
* @return a RingSet containing the rings in molecule
*/
public IRingSet findSSSR(IAtomContainer mol) {
IBond brokenBond = null;
IChemObjectBuilder builder = mol.getBuilder();
IRingSet sssr = builder.newInstance(IRingSet.class);
IAtomContainer molecule = builder.newInstance(IAtomContainer.class);
molecule.add(mol);
IAtom smallest;
int smallestDegree, nodesToBreakCounter, degree;
IAtom[] rememberNodes;
IRing ring;
// Two Vectors - as defined in the article. One to hold the
// full set of atoms in the structure and on to store the numbers
// of the nodes that have been trimmed away.
// Furhter there is a Vector nodesN2 to store the number of N2 nodes
List<IAtom> fullSet = new ArrayList<IAtom>();
List<IAtom> trimSet = new ArrayList<IAtom>();
List<IAtom> nodesN2 = new ArrayList<IAtom>();
initPath(molecule);
logger.debug("molecule.getAtomCount(): " + molecule.getAtomCount());
// load fullSet with the numbers of our atoms
for (int f = 0; f < molecule.getAtomCount(); f++) {
fullSet.add(molecule.getAtom(f));
}
logger.debug("fullSet.size(): " + fullSet.size());
do {
// Add nodes of degree zero to trimset.
// Also add nodes of degree 2 to nodesN2.
// In the same run, check, which node has the lowest degree
// greater than zero.
smallestDegree = 7;
smallest = null;
nodesN2.clear();
for (int f = 0; f < molecule.getAtomCount(); f++) {
IAtom atom = molecule.getAtom(f);
degree = molecule.getConnectedBondsCount(atom);
if (degree == 0) {
if (!trimSet.contains(atom)) {
logger.debug("Atom of degree 0");
trimSet.add(atom);
}
}
if (degree == 2) {
nodesN2.add(atom);
}
if (degree < smallestDegree && degree > 0) {
smallest = atom;
smallestDegree = degree;
}
}
if (smallest == null) break;
// If there are nodes of degree 1, trim them away
if (smallestDegree == 1) {
trimCounter++;
trim(smallest, molecule);
trimSet.add(smallest);
}
// if there are nodes of degree 2, find out of which rings
// they are part of.
else if (smallestDegree == 2) {
rememberNodes = new IAtom[nodesN2.size()];
nodesToBreakCounter = 0;
for (int f = 0; f < nodesN2.size(); f++) {
ring = getRing((IAtom) nodesN2.get(f), molecule);
if (ring != null) {
// check, if this ring already is in SSSR
if (!RingSetManipulator.ringAlreadyInSet(ring, sssr)) {
sssr.addAtomContainer(ring);
rememberNodes[nodesToBreakCounter] = (IAtom) nodesN2.get(f);
nodesToBreakCounter++;
}
}
}
if (nodesToBreakCounter == 0) {
nodesToBreakCounter = 1;
rememberNodes[0] = (IAtom) nodesN2.get(0);
}
for (int f = 0; f < nodesToBreakCounter; f++) {
breakBond(rememberNodes[f], molecule);
}
if (brokenBond != null) {
molecule.addBond(brokenBond);
brokenBond = null;
}
}
// if there are nodes of degree 3
else if (smallestDegree == 3) {
ring = getRing(smallest, molecule);
if (ring != null) {
// check, if this ring already is in SSSR
if (!RingSetManipulator.ringAlreadyInSet(ring, sssr)) {
sssr.addAtomContainer(ring);
}
brokenBond = checkEdges(ring, molecule);
molecule.removeElectronContainer(brokenBond);
}
}
} while (trimSet.size() < fullSet.size());
logger.debug("fullSet.size(): " + fullSet.size());
logger.debug("trimSet.size(): " + trimSet.size());
logger.debug("trimCounter: " + trimCounter);
// molecule.setProperty(CDKConstants.SMALLEST_RINGS, sssr);
return sssr;
}
