// minimum details /// <summary> Partitions a RingSet into RingSets of connected rings. Rings which share /// an Atom, a Bond or three or more atoms with at least on other ring in /// the RingSet are considered connected. /// /// </summary> /// <param name="ringSet"> The RingSet to be partitioned /// </param> /// <returns> A Vector of connected RingSets /// </returns> public static System.Collections.ArrayList partitionRings(IRingSet ringSet) { System.Collections.ArrayList ringSets = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); if (ringSet.AtomContainerCount == 0) { return(ringSets); } IRingSet tempRingSet = null; IRing ring = (IRing)ringSet.getAtomContainer(0); if (ring == null) { return(ringSets); } IRingSet rs = ring.Builder.newRingSet(); for (int f = 0; f < ringSet.AtomContainerCount; f++) { rs.addAtomContainer(ringSet.getAtomContainer(f)); } do { ring = (IRing)rs.getAtomContainer(0); IRingSet newRs = ring.Builder.newRingSet(); newRs.addAtomContainer(ring); tempRingSet = walkRingSystem(rs, ring, newRs); if (debug) { System.Console.Out.WriteLine("found ringset with ringcount: " + tempRingSet.AtomContainerCount); } ringSets.Add(walkRingSystem(rs, ring, newRs)); }while (rs.AtomContainerCount > 0); return(ringSets); }
/// <summary> Converts a RingSet to an AtomContainer. /// /// </summary> /// <param name="ringSet"> The RingSet to be converted. /// </param> /// <returns> The AtomContainer containing the bonds and atoms of the ringSet. /// </returns> public static IAtomContainer convertToAtomContainer(IRingSet ringSet) { IRing ring = (IRing)ringSet.getAtomContainer(0); if (ring == null) { return(null); } IAtomContainer ac = ring.Builder.newAtomContainer(); for (int i = 0; i < ringSet.AtomContainerCount; i++) { ring = (IRing)ringSet.getAtomContainer(i); for (int r = 0; r < ring.getBondCount(); r++) { IBond bond = ring.getBondAt(r); if (!ac.contains(bond)) { for (int j = 0; j < bond.AtomCount; j++) { ac.addAtom(bond.getAtomAt(j)); } ac.addBond(bond); } } } return(ac); }
// minimum details /// <summary> Partitions a RingSet into RingSets of connected rings. Rings which share /// an Atom, a Bond or three or more atoms with at least on other ring in /// the RingSet are considered connected. /// /// </summary> /// <param name="ringSet"> The RingSet to be partitioned /// </param> /// <returns> A Vector of connected RingSets /// </returns> public static System.Collections.ArrayList partitionRings(IRingSet ringSet) { System.Collections.ArrayList ringSets = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); if (ringSet.AtomContainerCount == 0) return ringSets; IRingSet tempRingSet = null; IRing ring = (IRing)ringSet.getAtomContainer(0); if (ring == null) return ringSets; IRingSet rs = ring.Builder.newRingSet(); for (int f = 0; f < ringSet.AtomContainerCount; f++) { rs.addAtomContainer(ringSet.getAtomContainer(f)); } do { ring = (IRing)rs.getAtomContainer(0); IRingSet newRs = ring.Builder.newRingSet(); newRs.addAtomContainer(ring); tempRingSet = walkRingSystem(rs, ring, newRs); if (debug) { System.Console.Out.WriteLine("found ringset with ringcount: " + tempRingSet.AtomContainerCount); } ringSets.Add(walkRingSystem(rs, ring, newRs)); } while (rs.AtomContainerCount > 0); return ringSets; }
/// <summary> Uses precomputed set of ALL rings and performs an aromaticity detection /// based on Hueckels 4n + 2 rule. /// /// </summary> /// <param name="ringSet"> set of ALL rings /// </param> /// <param name="removeAromaticityFlags"> Leaves ChemObjects that are already marked as /// aromatic as they are /// </param> /// <param name="atomContainer"> AtomContainer to be searched for rings /// </param> /// <returns> True, if molecules contains an /// aromatic feature /// </returns> public static bool detectAromaticity(IAtomContainer atomContainer, IRingSet ringSet, bool removeAromaticityFlags) { bool foundSomething = false; if (removeAromaticityFlags) { for (int f = 0; f < atomContainer.AtomCount; f++) { atomContainer.getAtomAt(f).setFlag(CDKConstants.ISAROMATIC, false); } for (int f = 0; f < atomContainer.ElectronContainerCount; f++) { IElectronContainer electronContainer = atomContainer.getElectronContainerAt(f); if (electronContainer is IBond) { electronContainer.setFlag(CDKConstants.ISAROMATIC, false); } } for (int f = 0; f < ringSet.AtomContainerCount; f++) { ((IRing)ringSet.getAtomContainer(f)).setFlag(CDKConstants.ISAROMATIC, false); } } IRing ring = null; RingSetManipulator.sort(ringSet); for (int f = 0; f < ringSet.AtomContainerCount; f++) { ring = (IRing)ringSet.getAtomContainer(f); //logger.debug("Testing for aromaticity in ring no ", f); if (AromaticityCalculator.isAromatic(ring, atomContainer)) { ring.setFlag(CDKConstants.ISAROMATIC, true); for (int g = 0; g < ring.AtomCount; g++) { ring.getAtomAt(g).setFlag(CDKConstants.ISAROMATIC, true); } for (int g = 0; g < ring.ElectronContainerCount; g++) { IElectronContainer electronContainer = ring.getElectronContainerAt(g); if (electronContainer is IBond) { electronContainer.setFlag(CDKConstants.ISAROMATIC, true); } } foundSomething = true; //logger.debug("This ring is aromatic: ", f); } else { //logger.debug("This ring is *not* aromatic: ", f); } } return(foundSomething); }
/// <summary> Adds all rings of another RingSet if they are not allready part of this ring set. /// /// </summary> /// <param name="ringSet"> the ring set to be united with this one. /// </param> public virtual void add(IRingSet ringSet) { for (int f = 0; f < ringSet.AtomContainerCount; f++) { if (!contains((IRing)ringSet.getAtomContainer(f))) { addAtomContainer(ringSet.getAtomContainer(f)); } } }
/// <summary> Returns the ring with the highest numbers of other rings attached to it. /// /// </summary> /// <returns> the ring with the highest numbers of other rings attached to it. /// </returns> public static IRing getMostComplexRing(IRingSet ringSet) { int[] neighbors = new int[ringSet.AtomContainerCount]; IRing ring1, ring2; IAtom atom1, atom2; int mostComplex = 0, mostComplexPosition = 0; /* for all rings in this RingSet */ for (int i = 0; i < ringSet.AtomContainerCount; i++) { /* Take each ring */ ring1 = (IRing)ringSet.getAtomContainer(i); /* look at each Atom in this ring whether it is part of any other ring */ for (int j = 0; j < ring1.AtomCount; j++) { atom1 = ring1.getAtomAt(j); /* Look at each of the other rings in the ringset */ for (int k = i + 1; k < ringSet.AtomContainerCount; k++) { ring2 = (IRing)ringSet.getAtomContainer(k); if (ring1 != ring2) { for (int l = 0; l < ring2.AtomCount; l++) { atom2 = ring2.getAtomAt(l); if (atom1 == atom2) { neighbors[i]++; neighbors[k]++; break; } } } } } } for (int i = 0; i < neighbors.Length; i++) { if (neighbors[i] > mostComplex) { mostComplex = neighbors[i]; mostComplexPosition = i; } } return((IRing)ringSet.getAtomContainer(mostComplexPosition)); }
private IRing combineRings(IRingSet ringset, int i, int j) { int c = 0; for (int b = 0; b < cb[i].Length; b++) { c = cb[i][b] + cb[j][b]; if (c > 1) { break; //at least one common bond } } if (c < 2) { return(null); } IRing ring = molecule.Builder.newRing(); IRing ring1 = (IRing)ringset.getAtomContainer(i); IRing ring2 = (IRing)ringset.getAtomContainer(j); for (int b = 0; b < cb[i].Length; b++) { c = cb[i][b] + cb[j][b]; if ((c == 1) && (cb[i][b] == 1)) { ring.addBond(molecule.getBondAt(b)); } else if ((c == 1) && (cb[j][b] == 1)) { ring.addBond(molecule.getBondAt(b)); } } for (int a = 0; a < ring1.AtomCount; a++) { ring.addAtom(ring1.getAtomAt(a)); } for (int a = 0; a < ring2.AtomCount; a++) { ring.addAtom(ring2.getAtomAt(a)); } return(ring); }
/// <summary> Returns all the atoms and bonds from all the rings in the RingSet /// in one AtomContainer. /// /// </summary> /// <returns> an AtomContainer with all atoms and bonds from the RingSet /// /// </returns> /// <deprecated> This method has a serious performace impact. Try to use /// other methods. /// </deprecated> public static IAtomContainer getAllInOneContainer(IRingSet ringSet) { // FIXME: make RingSet a subclass of IChemObject (see bug #) and clean up // the code in the next line IAtomContainer container = ringSet.Builder.newAtomContainer(); for (int i = 0; i < ringSet.AtomContainerCount; i++) { container.add((IRing)ringSet.getAtomContainer(i)); } return container; }
/// <summary> Returns all the atoms and bonds from all the rings in the RingSet /// in one AtomContainer. /// /// </summary> /// <returns> an AtomContainer with all atoms and bonds from the RingSet /// /// </returns> /// <deprecated> This method has a serious performace impact. Try to use /// other methods. /// </deprecated> public static IAtomContainer getAllInOneContainer(IRingSet ringSet) { // FIXME: make RingSet a subclass of IChemObject (see bug #) and clean up // the code in the next line IAtomContainer container = ringSet.Builder.newAtomContainer(); for (int i = 0; i < ringSet.AtomContainerCount; i++) { container.add((IRing)ringSet.getAtomContainer(i)); } return(container); }
/// <summary> Returns the geometric center of all the rings in this ringset. /// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets /// /// </summary> /// <param name="ringSet"> Description of the Parameter /// </param> /// <returns> the geometric center of the rings in this ringset /// </returns> public static Point2d get2DCenter(IRingSet ringSet) { double centerX = 0; double centerY = 0; for (int i = 0; i < ringSet.AtomContainerCount; i++) { Point2d centerPoint = GeometryTools.get2DCenter((IRing)ringSet.getAtomContainer(i)); centerX += centerPoint.x; centerY += centerPoint.y; } Point2d point = new Point2d(centerX / ((double)ringSet.AtomContainerCount), centerY / ((double)ringSet.AtomContainerCount)); return point; }
/// <summary> Uses precomputed set of ALL rings and performs an aromaticity detection /// based on Hueckels 4n + 2 rule. /// /// </summary> /// <param name="ringSet"> set of ALL rings /// </param> /// <param name="removeAromaticityFlags"> Leaves ChemObjects that are already marked as /// aromatic as they are /// </param> /// <param name="atomContainer"> AtomContainer to be searched for rings /// </param> /// <returns> True, if molecules contains an /// aromatic feature /// </returns> public static bool detectAromaticity(IAtomContainer atomContainer, IRingSet ringSet, bool removeAromaticityFlags) { bool foundSomething = false; if (removeAromaticityFlags) { for (int f = 0; f < atomContainer.AtomCount; f++) { atomContainer.getAtomAt(f).setFlag(CDKConstants.ISAROMATIC, false); } for (int f = 0; f < atomContainer.ElectronContainerCount; f++) { IElectronContainer electronContainer = atomContainer.getElectronContainerAt(f); if (electronContainer is IBond) { electronContainer.setFlag(CDKConstants.ISAROMATIC, false); } } for (int f = 0; f < ringSet.AtomContainerCount; f++) { ((IRing)ringSet.getAtomContainer(f)).setFlag(CDKConstants.ISAROMATIC, false); } } IRing ring = null; RingSetManipulator.sort(ringSet); for (int f = 0; f < ringSet.AtomContainerCount; f++) { ring = (IRing)ringSet.getAtomContainer(f); //logger.debug("Testing for aromaticity in ring no ", f); if (AromaticityCalculator.isAromatic(ring, atomContainer)) { ring.setFlag(CDKConstants.ISAROMATIC, true); for (int g = 0; g < ring.AtomCount; g++) { ring.getAtomAt(g).setFlag(CDKConstants.ISAROMATIC, true); } for (int g = 0; g < ring.ElectronContainerCount; g++) { IElectronContainer electronContainer = ring.getElectronContainerAt(g); if (electronContainer is IBond) { electronContainer.setFlag(CDKConstants.ISAROMATIC, true); } } foundSomething = true; //logger.debug("This ring is aromatic: ", f); } else { //logger.debug("This ring is *not* aromatic: ", f); } } return foundSomething; }
private IRing combineRings(IRingSet ringset, int i, int j) { int c = 0; for (int b = 0; b < cb[i].Length; b++) { c = cb[i][b] + cb[j][b]; if (c > 1) break; //at least one common bond } if (c < 2) return null; IRing ring = molecule.Builder.newRing(); IRing ring1 = (IRing)ringset.getAtomContainer(i); IRing ring2 = (IRing)ringset.getAtomContainer(j); for (int b = 0; b < cb[i].Length; b++) { c = cb[i][b] + cb[j][b]; if ((c == 1) && (cb[i][b] == 1)) ring.addBond(molecule.getBondAt(b)); else if ((c == 1) && (cb[j][b] == 1)) ring.addBond(molecule.getBondAt(b)); } for (int a = 0; a < ring1.AtomCount; a++) ring.addAtom(ring1.getAtomAt(a)); for (int a = 0; a < ring2.AtomCount; a++) ring.addAtom(ring2.getAtomAt(a)); return ring; }
/// <summary> Converts a RingSet to an AtomContainer. /// /// </summary> /// <param name="ringSet"> The RingSet to be converted. /// </param> /// <returns> The AtomContainer containing the bonds and atoms of the ringSet. /// </returns> public static IAtomContainer convertToAtomContainer(IRingSet ringSet) { IRing ring = (IRing)ringSet.getAtomContainer(0); if (ring == null) return null; IAtomContainer ac = ring.Builder.newAtomContainer(); for (int i = 0; i < ringSet.AtomContainerCount; i++) { ring = (IRing)ringSet.getAtomContainer(i); for (int r = 0; r < ring.getBondCount(); r++) { IBond bond = ring.getBondAt(r); if (!ac.contains(bond)) { for (int j = 0; j < bond.AtomCount; j++) { ac.addAtom(bond.getAtomAt(j)); } ac.addBond(bond); } } } return ac; }
/// <summary> Returns the ring with the highest numbers of other rings attached to it. /// /// </summary> /// <returns> the ring with the highest numbers of other rings attached to it. /// </returns> public static IRing getMostComplexRing(IRingSet ringSet) { int[] neighbors = new int[ringSet.AtomContainerCount]; IRing ring1, ring2; IAtom atom1, atom2; int mostComplex = 0, mostComplexPosition = 0; /* for all rings in this RingSet */ for (int i = 0; i < ringSet.AtomContainerCount; i++) { /* Take each ring */ ring1 = (IRing)ringSet.getAtomContainer(i); /* look at each Atom in this ring whether it is part of any other ring */ for (int j = 0; j < ring1.AtomCount; j++) { atom1 = ring1.getAtomAt(j); /* Look at each of the other rings in the ringset */ for (int k = i + 1; k < ringSet.AtomContainerCount; k++) { ring2 = (IRing)ringSet.getAtomContainer(k); if (ring1 != ring2) { for (int l = 0; l < ring2.AtomCount; l++) { atom2 = ring2.getAtomAt(l); if (atom1 == atom2) { neighbors[i]++; neighbors[k]++; break; } } } } } } for (int i = 0; i < neighbors.Length; i++) { if (neighbors[i] > mostComplex) { mostComplex = neighbors[i]; mostComplexPosition = i; } } return (IRing)ringSet.getAtomContainer(mostComplexPosition); }