/** * 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); }
/** * 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; }
/** * 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; }
/** * 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; }
/** * The basic rings of the spanning tree. Using the pruned edges, return any path * which connects the end points of the pruned edge in the tree. These paths form * cycles. * * @return basic rings * @throws NoSuchAtomException atoms not found in the molecule */ public IRingSet getBasicRings() throws NoSuchAtomException { IRingSet ringset = molecule.getBuilder().newInstance(IRingSet.class); IAtomContainer spt = getSpanningTree(); for (int i = 0; i < totalEdgeCount; i++) if (!bondsInTree[i]) ringset.addAtomContainer(getRing(spt, molecule.getBond(i))); return ringset; }
/** * The basic rings of the spanning tree. Using the pruned edges, return any path * which connects the end points of the pruned edge in the tree. These paths form * cycles. * * @return basic rings * @throws NoSuchAtomException atoms not found in the molecule */ public IRingSet getBasicRings() throws NoSuchAtomException { IRingSet ringset = molecule.getBuilder().newInstance(IRingSet.class); IAtomContainer spt = getSpanningTree(); for (int i = 0; i < totalEdgeCount; i++) if (!bondsInTree[i]) ringset.addAtomContainer(getRing(spt, molecule.getBond(i))); return ringset; }
/** * Returns a vector of all rings that this bond is part of. * * @param bond The bond to be checked * @return A vector of all rings that this bond is part of */ @Override public IRingSet getRings(IBond bond) { IRingSet rings = bond.getBuilder().newInstance(IRingSet.class); Ring ring; for (int i = 0; i < getAtomContainerCount(); i++) { ring = (Ring) getAtomContainer(i); if (ring.contains(bond)) { rings.addAtomContainer(ring); } } return rings; }
/** * Returns a vector of all rings that this bond is part of. * * @param bond The bond to be checked * @return A vector of all rings that this bond is part of */ @Override public IRingSet getRings(IBond bond) { IRingSet rings = bond.getBuilder().newInstance(IRingSet.class); Ring ring; for (int i = 0; i < getAtomContainerCount(); i++) { ring = (Ring) getAtomContainer(i); if (ring.contains(bond)) { rings.addAtomContainer(ring); } } return rings; }
@Test public void testGetAllAtomContainers_IRingSet() { IRingSet rs = builder.newInstance(IRingSet.class); rs.addAtomContainer(builder.newInstance(IRing.class)); rs.addAtomContainer(builder.newInstance(IRing.class)); List<IAtomContainer> list = RingSetManipulator.getAllAtomContainers(rs); Assert.assertEquals(2, list.size()); }
/** * Returns a vector of all rings that this bond is part of. * * @param bond The bond to be checked * @return A vector of all rings that this bond is part of */ @Override public IRingSet getRings(IBond bond) { IRingSet rings = bond.getBuilder().newInstance(IRingSet.class); Ring ring; for (int i = 0; i < getAtomContainerCount(); i++) { ring = (Ring) getAtomContainer(i); if (ring.contains(bond)) { rings.addAtomContainer(ring); } } return rings; }
@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)); }
@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()); }
@Test public void testGetAtomCount_IRingSet() { IRingSet rs = builder.newInstance(IRingSet.class); IAtomContainer ac1 = builder.newInstance(IRing.class); ac1.addAtom(builder.newInstance(IAtom.class, "O")); rs.addAtomContainer(ac1); IAtomContainer ac2 = builder.newInstance(IRing.class); ac2.addAtom(builder.newInstance(IAtom.class, "C")); ac2.addAtom(builder.newInstance(IAtom.class, "C")); ac2.addBond(0, 1, IBond.Order.DOUBLE); rs.addAtomContainer(ac2); Assert.assertEquals(3, RingSetManipulator.getAtomCount(rs)); Assert.assertEquals(1, RingSetManipulator.getBondCount(rs)); }
@Test public void testRingAlreadyInSet_IRing_IRingSet() { IRing r1 = builder.newInstance(IRing.class, 5, "C"); IRing r2 = builder.newInstance(IRing.class, 3, "C"); IRingSet rs = builder.newInstance(IRingSet.class); Assert.assertFalse(RingSetManipulator.ringAlreadyInSet(r1, rs)); Assert.assertFalse(RingSetManipulator.ringAlreadyInSet(r2, rs)); rs.addAtomContainer(r1); Assert.assertTrue(RingSetManipulator.ringAlreadyInSet(r1, rs)); Assert.assertFalse(RingSetManipulator.ringAlreadyInSet(r2, rs)); rs.addAtomContainer(r2); Assert.assertTrue(RingSetManipulator.ringAlreadyInSet(r1, rs)); Assert.assertTrue(RingSetManipulator.ringAlreadyInSet(r2, rs)); }
@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)); }
@Test public void testStateChanged_EventPropagation_RingSet() { ChemObjectListenerImpl listener = new ChemObjectListenerImpl(); IChemModel chemObject = (IChemModel) newChemObject(); chemObject.addListener(listener); IRingSet ringSet = chemObject.getBuilder().newInstance(IRingSet.class); chemObject.setRingSet(ringSet); Assert.assertTrue(listener.changed); // reset the listener listener.reset(); Assert.assertFalse(listener.changed); // changing the set should trigger a change event in the IChemModel ringSet.addAtomContainer(chemObject.getBuilder().newInstance(IRing.class)); Assert.assertTrue(listener.changed); }
@Test public void testStateChanged_ButNotAfterRemoval_RingSet() { ChemObjectListenerImpl listener = new ChemObjectListenerImpl(); IChemModel chemObject = (IChemModel) newChemObject(); chemObject.addListener(listener); IRingSet ringSet = chemObject.getBuilder().newInstance(IRingSet.class); chemObject.setRingSet(ringSet); Assert.assertTrue(listener.changed); // remove the set from the IChemModel chemObject.setRingSet(null); // reset the listener listener.reset(); Assert.assertFalse(listener.changed); // changing the set must *not* trigger a change event in the IChemModel ringSet.addAtomContainer(chemObject.getBuilder().newInstance(IRing.class)); Assert.assertFalse(listener.changed); }
@Test public void testIsEmpty_RingSet() { IChemModel model = (IChemModel) newChemObject(); IChemObjectBuilder builder = model.getBuilder(); IAtomContainer container = builder.newInstance(IAtomContainer.class); IRingSet ringset = builder.newInstance(IRingSet.class); Assert.assertTrue(model.isEmpty()); model.setRingSet(ringset); Assert.assertTrue(model.isEmpty()); ringset.addAtomContainer(container); Assert.assertFalse(model.isEmpty()); model.setRingSet(null); Assert.assertTrue(model.isEmpty()); }
@Test public void testGet2DCenter_IRingSet() { Atom atom1 = new Atom("C"); atom1.setPoint2d(new Point2d(1, 1)); Atom atom2 = new Atom("C"); atom2.setPoint2d(new Point2d(1, 0)); IRing ac = DefaultChemObjectBuilder.getInstance().newInstance(IRing.class); ac.addAtom(atom1); ac.addAtom(atom2); IRingSet ringset = DefaultChemObjectBuilder.getInstance().newInstance(IRingSet.class); ringset.addAtomContainer(ac); Point2d p = GeometryUtil.get2DCenter(ac); Assert.assertEquals(p.x, 1.0, .1); Assert.assertEquals(p.y, 0.5, .1); }
@Test @Override public void testStateChanged_EventPropagation_RingSet() { ChemObjectListener listener = new ChemObjectListener(); IChemModel chemObject = (IChemModel) newChemObject(); chemObject.addListener(listener); IRingSet ringSet = chemObject.getBuilder().newInstance(IRingSet.class); chemObject.setRingSet(ringSet); Assert.assertFalse(listener.getChanged()); // reset the listener listener.reset(); Assert.assertFalse(listener.getChanged()); // changing the set should trigger a change event in the IChemModel ringSet.addAtomContainer(chemObject.getBuilder().newInstance(IRing.class)); Assert.assertFalse(listener.getChanged()); }