private boolean inRingSet(IAtom atom, IRingSet ringSet) { for (int i = 0; i < ringSet.getAtomContainerCount(); i++) { IRing ring = (IRing) ringSet.getAtomContainer(i); if (ring.contains(atom)) return true; } return false; }
/** * * @param ringBond * @param singleRings * @return */ public static IRingSet getSmallestRingSet(IBond ringBond, IRingSet singleRings) { IRingSet rs = new RingSet(); for (IAtomContainer ring : singleRings.atomContainers()) { if (ring.contains(ringBond.getAtom(0)) && ring.contains(ringBond.getAtom(1))) { if (rs.getAtomContainerCount() == 0) { rs.addAtomContainer(ring); continue; } for (IAtomContainer smallestRing : rs.atomContainers()) { if (ring.getAtomCount() == smallestRing.getAtomCount()) { if (!rs.contains(ring)) { rs.addAtomContainer(ring); } } else if (ring.getAtomCount() < smallestRing.getAtomCount()) { rs.removeAllAtomContainers(); rs.addAtomContainer(ring); } } } } return rs; }
private String getRingcode(IAtom root, IAtomContainer ac) { if (ac != acold) { soar = Cycles.sssr(ac).toRingSet(); } boolean[] bool = new boolean[1000]; StringBuffer sb = new StringBuffer(); for (int i = 0; i < soar.getRings(root).getAtomContainerCount(); i++) { if (((IRing) soar.getRings(root).getAtomContainer(i)).getAtomCount() < bool.length) bool[((IRing) soar.getRings(root).getAtomContainer(i)).getAtomCount()] = true; } for (int i = 0; i < bool.length; i++) { if (bool[i]) sb.append(i + ""); } if (sb.toString().isEmpty()) return ""; else return "-" + sb.toString(); }
/** * Perform a walk in the given RingSet, starting at a given Ring and * recursively searching for other Rings connected to this ring. By doing * this it finds all rings in the RingSet connected to the start ring, * putting them in newRs, and removing them from rs. * *@param rs The RingSet to be searched *@param ring The ring to start with *@param newRs The RingSet containing all Rings connected to ring *@return newRs The RingSet containing all Rings connected to ring */ private static IRingSet walkRingSystem(IRingSet rs, IRing ring, IRingSet newRs) { IRing tempRing; IRingSet tempRings = rs.getConnectedRings(ring); // logger.debug("walkRingSystem -> tempRings.size(): " + tempRings.size()); rs.removeAtomContainer(ring); for (IAtomContainer container : tempRings.atomContainers()) { tempRing = (IRing) container; if (!newRs.contains(tempRing)) { newRs.addAtomContainer(tempRing); newRs.add(walkRingSystem(rs, tempRing, newRs)); } } return newRs; }
/** * Sorts the rings in the set by size. The smallest ring comes * first. * @param ringSet The collection of rings */ public static void sort(IRingSet ringSet) { List<IRing> ringList = new ArrayList<IRing>(); for (IAtomContainer atomContainer : ringSet.atomContainers()) { ringList.add((IRing) atomContainer); } Collections.sort(ringList, new RingSizeComparator(RingSizeComparator.SMALL_FIRST)); ringSet.removeAllAtomContainers(); for (IAtomContainer aRingList : ringList) ringSet.addAtomContainer(aRingList); }
if (allRings != null && allRings.contains(atom)) { // it's in a ring atom.setFlag(CDKConstants.ISINRING, true); atom.setFlag(CDKConstants.ISALIPHATIC, false); IRingSet currentRings = allRings.getRings(atom); int min = 0; for (int i = 0; i < currentRings.getAtomContainerCount(); i++) { int size = currentRings.getAtomContainer(i).getAtomCount(); if (min > size) { min = size; atom.setProperty(CDKConstants.SMALLEST_RINGS, sssr.getRings(atom)); atom.setProperty(SMALLEST_RING_SIZE, min); } else { if (allRings != null && allRings.getRings(bond).getAtomContainerCount() > 0) { bond.setFlag(CDKConstants.ISINRING, true); bond.setFlag(CDKConstants.ISALIPHATIC, false);
atomRingSet = rs.getRings(atomi); atomi.setProperty("IS_IN_AROMATIC_RING", false); atomi.setProperty(CDKConstants.PART_OF_RING_OF_SIZE, 0); if (atomRingSet.getAtomContainerCount() > 0) { if (atomRingSet.getAtomContainerCount() > 1) { Iterator<IAtomContainer> containers = RingSetManipulator.getAllAtomContainers(atomRingSet) .iterator(); atomRingSet = rs.getBuilder().newInstance(IRingSet.class); while (containers.hasNext()) { atomRingSet.add(Cycles.essential(containers.next()).toRingSet()); for (int j = 0; j < atomRingSet.getAtomContainerCount(); j++) { if (j == 0) { atomi.setProperty(CDKConstants.PART_OF_RING_OF_SIZE, ((IRing) atomRingSet.getAtomContainer(j)).getRingSize()); if (((IRing) atomRingSet.getAtomContainer(j)).contains(atomi)) { if (((IRing) atomRingSet.getAtomContainer(j)).getRingSize() >= 6 && atomi.getFlag(CDKConstants.ISAROMATIC)) { atomi.setProperty("IS_IN_AROMATIC_RING", true); if (((IRing) atomRingSet.getAtomContainer(j)).getRingSize() < (Integer) atomi .getProperty(CDKConstants.PART_OF_RING_OF_SIZE)) { atomi.setProperty(CDKConstants.PART_OF_RING_OF_SIZE, ((IRing) atomRingSet.getAtomContainer(j)).getRingSize()); || (rs.contains(atomi)
IAtom atom = null; IRingSet rings = null; IAtomContainer unplacedPartners = rs.getBuilder().newInstance(IAtomContainer.class); IAtomContainer sharedAtoms = rs.getBuilder().newInstance(IAtomContainer.class); IAtomContainer primaryAtoms = rs.getBuilder().newInstance(IAtomContainer.class); IAtomContainer treatedAtoms = rs.getBuilder().newInstance(IAtomContainer.class); Point2d centerOfRingGravity = null; for (int j = 0; j < rs.getAtomContainerCount(); j++) { ring = (IRing) rs.getAtomContainer(j); /* primaryAtoms.removeAllElements(); atom = ring.getAtom(k); rings = rs.getRings(atom); centerOfRingGravity = GeometryUtil.get2DCenter(rings); atomPlacer.partitionPartners(atom, unplacedPartners, sharedAtoms);
private List<IBond> getSplitableBonds(IAtomContainer atomContainer) throws CDKException { // do ring detection SpanningTree spanningTree = new SpanningTree(atomContainer); IRingSet allRings = spanningTree.getAllRings(); // find the splitable bonds ArrayList<IBond> splitableBonds = new ArrayList<IBond>(); for (IBond bond : atomContainer.bonds()) { boolean isInRing = false; boolean isTerminal = false; // lets see if it's in a ring IRingSet rings = allRings.getRings(bond); if (rings.getAtomContainerCount() != 0) isInRing = true; // lets see if it is a terminal bond for (IAtom atom : bond.atoms()) { if (atomContainer.getConnectedBondsCount(atom) == 1) { isTerminal = true; break; } } if (!(isInRing || isTerminal)) splitableBonds.add(bond); } return splitableBonds; }
IAtom ring1Atom1 = ringset.getBuilder().newInstance(IAtom.class, "C"); // rather artificial molecule IAtom ring1Atom2 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom sharedAtom1 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom sharedAtom2 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom ring2Atom1 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom ring2Atom2 = ringset.getBuilder().newInstance(IAtom.class, "C"); IBond ring1Bond1 = ringset.getBuilder().newInstance(IBond.class, ring1Atom1, ring1Atom2); IBond ring1Bond2 = ringset.getBuilder().newInstance(IBond.class, sharedAtom1, ring1Atom1); IBond ring1Bond3 = ringset.getBuilder().newInstance(IBond.class, sharedAtom2, ring1Atom2); IBond sharedBond = ringset.getBuilder().newInstance(IBond.class, sharedAtom1, sharedAtom2); IBond ring2Bond1 = ringset.getBuilder().newInstance(IBond.class, ring2Atom1, ring2Atom2); IBond ring2Bond2 = ringset.getBuilder().newInstance(IBond.class, sharedAtom1, ring2Atom1); IBond ring2Bond3 = ringset.getBuilder().newInstance(IBond.class, sharedAtom2, ring2Atom2); IRing ring1 = ringset.getBuilder().newInstance(IRing.class); ring1.addAtom(ring1Atom1); ring1.addAtom(ring1Atom2); ring1.addBond(ring1Bond3); ring1.addBond(sharedBond); IRing ring2 = ringset.getBuilder().newInstance(IRing.class); ring2.addAtom(ring2Atom1); ring2.addAtom(ring2Atom2); ringset.addAtomContainer(ring1); ringset.addAtomContainer(ring2); Assert.assertEquals(1, ringset.getRings(ring1Bond1).getAtomContainerCount()); Assert.assertEquals(1, ringset.getRings(ring1Bond2).getAtomContainerCount());
@Test public void testGetBasicRings() throws Exception { IRingSet ringSet = azulene.getBasicRings(); Assert.assertEquals(2, ringSet.getAtomContainerCount()); ringSet = ethane.getBasicRings(); Assert.assertEquals(0, ringSet.getAtomContainerCount()); }
@Test @Override public void testClone() throws CloneNotSupportedException { IRingSet ringset = (IRingSet) newChemObject(); IRing ring = ringset.getBuilder().newInstance(IRing.class); ringset.addAtomContainer(ring); IRingSet clone = (IRingSet) ringset.clone(); Assert.assertNotNull(clone); Assert.assertTrue(clone instanceof IRingSet); Assert.assertEquals(1, clone.getAtomContainerCount()); Assert.assertNotSame(ring, clone.getAtomContainer(0)); }
/** * Returns all the AtomContainer's in a RingSet. * @param set The collection of rings * @return A list of IAtomContainer objects corresponding to individual rings */ public static List<IAtomContainer> getAllAtomContainers(IRingSet set) { List<IAtomContainer> atomContainerList = new ArrayList<IAtomContainer>(); for (IAtomContainer atomContainer : set.atomContainers()) { atomContainerList.add(atomContainer); } return atomContainerList; }
@Test public void testAdd_IRingSet() { IRingSet rs = (IRingSet) newChemObject(); IRing r1 = rs.getBuilder().newInstance(IRing.class, 5, "C"); IRing r2 = rs.getBuilder().newInstance(IRing.class, 3, "C"); rs.addAtomContainer(r1); IRingSet rs2 = (IRingSet) newChemObject(); rs2.addAtomContainer(r2); rs2.add(rs); Assert.assertEquals(1, rs.getAtomContainerCount()); Assert.assertEquals(2, rs2.getAtomContainerCount()); }
/** * Returns all the rings in the RingSet that share * one or more atoms with a given ring. * * @param ring A ring with which all return rings must share one or more atoms * @return All the rings that share one or more atoms with a given ring. */ @Override public IRingSet getConnectedRings(IRing ring) { IRingSet connectedRings = ring.getBuilder().newInstance(IRingSet.class); IRing tempRing; IAtom atom; for (int i = 0; i < ring.getAtomCount(); i++) { atom = ring.getAtom(i); for (int j = 0; j < getAtomContainerCount(); j++) { tempRing = (IRing) getAtomContainer(j); if (tempRing != ring && !connectedRings.contains(tempRing) && tempRing.contains(atom)) { connectedRings.addAtomContainer(tempRing); } } } return connectedRings; }
/** * Returns a vector of all rings that this atom is part of. * * @param atom The atom to be checked * @return A vector of all rings that this bond is part of */ @Override public IRingSet getRings(IAtom atom) { IRingSet rings = new RingSet(); IRing ring; for (int i = 0; i < getAtomContainerCount(); i++) { ring = (Ring) getAtomContainer(i); if (ring.contains(atom)) { rings.addAtomContainer(ring); } } return rings; }
IAtom ring1Atom1 = ringset.getBuilder().newInstance(IAtom.class, "C"); // rather artificial molecule IAtom ring1Atom2 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom sharedAtom1 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom sharedAtom2 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom ring2Atom1 = ringset.getBuilder().newInstance(IAtom.class, "C"); IAtom ring2Atom2 = ringset.getBuilder().newInstance(IAtom.class, "C"); IBond ring1Bond1 = ringset.getBuilder().newInstance(IBond.class, ring1Atom1, ring1Atom2); IBond ring1Bond2 = ringset.getBuilder().newInstance(IBond.class, sharedAtom1, ring1Atom1); IBond ring1Bond3 = ringset.getBuilder().newInstance(IBond.class, sharedAtom2, ring1Atom2); IBond sharedBond = ringset.getBuilder().newInstance(IBond.class, sharedAtom1, sharedAtom2); IBond ring2Bond1 = ringset.getBuilder().newInstance(IBond.class, ring2Atom1, ring2Atom2); IBond ring2Bond2 = ringset.getBuilder().newInstance(IBond.class, sharedAtom1, ring2Atom1); IBond ring2Bond3 = ringset.getBuilder().newInstance(IBond.class, sharedAtom2, ring2Atom2); IRing ring1 = ringset.getBuilder().newInstance(IRing.class); ring1.addAtom(ring1Atom1); ring1.addAtom(ring1Atom2); ring1.addBond(ring1Bond3); ring1.addBond(sharedBond); IRing ring2 = ringset.getBuilder().newInstance(IRing.class); ring2.addAtom(ring2Atom1); ring2.addAtom(ring2Atom2); ringset.addAtomContainer(ring1); ringset.addAtomContainer(ring2); Assert.assertTrue(ringset.contains(ring1Atom1)); Assert.assertTrue(ringset.contains(ring1Atom2));
/** * We define the heaviest ring as the one with the highest number of double bonds. * Needed for example for the placement of in-ring double bonds. * * @param ringSet The collection of rings * @param bond A bond which must be contained by the heaviest ring * @return The ring with the higest number of double bonds connected to a given bond */ public static IRing getHeaviestRing(IRingSet ringSet, IBond bond) { IRingSet rings = ringSet.getRings(bond); IRing ring = null; int maxOrderSum = 0; for (Object ring1 : rings.atomContainers()) { if (maxOrderSum < ((IRing) ring1).getBondOrderSum()) { ring = (IRing) ring1; maxOrderSum = ring.getBondOrderSum(); } } return ring; }
@Test @Override public void testIsEmpty() { IRingSet ringSet = (IRingSet) newChemObject(); Assert.assertThat("new ringset should be empty", ringSet.isEmpty(), is(true)); ringSet.addAtomContainer(ringSet.getBuilder().newInstance(IAtomContainer.class)); Assert.assertThat("ringset with an atom container should not be empty", ringSet.isEmpty(), is(not(true))); ringSet.removeAllAtomContainers(); Assert.assertThat("ringset with removed atom containers should be empty", ringSet.isEmpty(), is(true)); }
/** * Sets all bonds in an {@link IRingSet} to single order. * @param ringGroup * @param ringSet * @return True for success */ private Boolean setAllRingBondsSingleOrder(List<Integer> ringGroup, IRingSet ringSet) { for (Integer i : ringGroup) { for (IBond bond : ringSet.getAtomContainer(i).bonds()) { bond.setOrder(IBond.Order.SINGLE); } } return true; }