/** * clean the flags CDKConstants.REACTIVE_CENTER from the molecule. * * @param ac */ private void cleanFlagReactiveCenter(IAtomContainer ac) { for (int j = 0; j < ac.getAtomCount(); j++) ac.getAtom(j).setFlag(CDKConstants.REACTIVE_CENTER, false); for (int j = 0; j < ac.getBondCount(); j++) ac.getBond(j).setFlag(CDKConstants.REACTIVE_CENTER, false); } }
@Override public IAtomContainer apply(Map<IChemObject, IChemObject> map) { final IAtomContainer submol = target.getBuilder() .newInstance(IAtomContainer.class, query.getAtomCount(), target.getBondCount(), 0, 0); for (IAtom atom : query.atoms()) submol.addAtom((IAtom)map.get(atom)); for (IBond bond : query.bonds()) submol.addBond((IBond)map.get(bond)); return submol; } });
private boolean isBridgeHead(int v) { if (getRingDegree(v) < 3) return false; IAtom atom = container.getAtom(v); for (IBond bond : container.getConnectedBondsList(atom)) if (isFusedBond(bond)) return false; return true; }
/** * Constructs an array of Bond objects from an AtomContainer. * @param container The original AtomContainer. * @return The array of Bond objects. */ public static IBond[] getBondArray(IAtomContainer container) { IBond[] ret = new IBond[container.getBondCount()]; for (int i = 0; i < ret.length; ++i) ret[i] = container.getBond(i); return ret; }
private IBond getBond(int i) { if (molecule.getBondCount() <= i) { molecule.addBond(molecule.getBuilder().newInstance(IBond.class)); } return molecule.getBond(i); }
@Test public void testBondId() throws Exception { String cmlString = "<molecule id='m1'><atomArray><atom id='a1'/><atom id='a2'/></atomArray><bondArray><bond id='b1' atomRefs2='a1 a2'/></bondArray></molecule>"; IChemFile chemFile = parseCMLString(cmlString); IAtomContainer mol = checkForSingleMoleculeFile(chemFile); Assert.assertEquals(2, mol.getAtomCount()); Assert.assertEquals(1, mol.getBondCount()); org.openscience.cdk.interfaces.IBond bond = mol.getBond(0); Assert.assertEquals("b1", bond.getID()); }
private IAtom getAtom(int i) { if (molecule.getAtomCount() <= i) { molecule.addAtom(molecule.getBuilder().newInstance(IAtom.class)); } return molecule.getAtom(i); }
@Test public void testGetMinBondOrderHighBondOrder() { IAtomContainer container = (IAtomContainer) newChemObject(); IChemObjectBuilder builder = container.getBuilder(); container.addAtom(builder.newAtom()); container.addAtom(builder.newAtom()); container.addBond(0, 1, IBond.Order.SEXTUPLE); assertThat(container.getMinimumBondOrder(container.getAtom(0)), is(IBond.Order.SEXTUPLE)); }
@Test public void testAtom() throws Exception { IAtomContainer mol = new AtomContainer(); Atom atom = new Atom("N"); mol.addAtom(atom); IAtomContainer roundTrippedMol = CMLRoundTripTool.roundTripMolecule(convertor, mol); Assert.assertEquals(1, roundTrippedMol.getAtomCount()); IAtom roundTrippedAtom = roundTrippedMol.getAtom(0); Assert.assertEquals(atom.getSymbol(), roundTrippedAtom.getSymbol()); }
public void ccBondTest(IBond.Order order) { IAtomContainer cc = builder.newInstance(IAtomContainer.class); cc.addAtom(builder.newInstance(IAtom.class, "C")); cc.addAtom(builder.newInstance(IAtom.class, "C")); cc.addBond(0, 1, order); String signature = signatureForAtom(cc, 0); IAtomContainer reconstructed = reconstruct(signature); Assert.assertEquals(2, reconstructed.getAtomCount()); Assert.assertEquals(1, reconstructed.getBondCount()); Assert.assertEquals(order, reconstructed.getBond(0).getOrder()); }
/** * @cdk.bug 1875949 */ @org.junit.Test public void testResonanceStructure() throws Exception { String smiles = "[F+]=C-[C-]"; IAtomContainer mol = sp.parseSmiles(smiles); Assert.assertEquals(3, mol.getAtomCount()); Assert.assertEquals(IBond.Order.DOUBLE, mol.getBond(0).getOrder()); Assert.assertEquals(+1, mol.getAtom(0).getFormalCharge().intValue()); Assert.assertEquals(-1, mol.getAtom(2).getFormalCharge().intValue()); }
@Test public void dontSuppressHydrogensOnPseudoAtoms() throws Exception { IAtomContainer mol = new AtomContainer(); // *[H] mol.addAtom(new PseudoAtom("*")); mol.addAtom(new Atom("H")); mol.getAtom(0).setImplicitHydrogenCount(0); mol.getAtom(1).setImplicitHydrogenCount(1); mol.addBond(0, 1, Order.SINGLE); Assert.assertEquals(2, mol.getAtomCount()); IAtomContainer ac = AtomContainerManipulator.removeHydrogens(mol); Assert.assertEquals(2, ac.getAtomCount()); }
static IAtomContainer but2ene() { IAtomContainer container = new AtomContainer(); container.addAtom(atom("C", 1)); container.addAtom(atom("C", 1)); container.addAtom(atom("C", 3)); container.addAtom(atom("C", 3)); container.addBond(0, 1, IBond.Order.DOUBLE); container.addBond(0, 2, IBond.Order.SINGLE); container.addBond(1, 3, IBond.Order.SINGLE); return container; }
@Test public void testAtomContainer_int_int_int_int() { // create an empty container with predefined // array lengths IAtomContainer ac = new AtomContainer(5, 6, 1, 2); Assert.assertEquals(0, ac.getAtomCount()); Assert.assertEquals(0, ac.getElectronContainerCount()); // test whether the ElectronContainer is correctly initialized ac.addBond(ac.getBuilder().newInstance(IBond.class, ac.getBuilder().newInstance(IAtom.class, "C"), ac.getBuilder().newInstance(IAtom.class, "C"), IBond.Order.DOUBLE)); ac.addLonePair(ac.getBuilder().newInstance(ILonePair.class, ac.getBuilder().newInstance(IAtom.class, "N"))); }
public static void addRing(int atomToAttachTo, int ringSize, IAtomContainer mol) { int numberOfAtoms = mol.getAtomCount(); int previous = atomToAttachTo; for (int i = 0; i < ringSize; i++) { mol.addAtom(builder.newInstance(IAtom.class, "C")); int current = numberOfAtoms + i; mol.addBond(previous, current, IBond.Order.SINGLE); previous = current; } mol.addBond(numberOfAtoms, numberOfAtoms + (ringSize - 1), IBond.Order.SINGLE); }
@Test public void testGetFirstAtom() { IAtomContainer container = (IAtomContainer) newChemObject(); IAtom c1 = container.getBuilder().newInstance(IAtom.class, "C"); IAtom c2 = container.getBuilder().newInstance(IAtom.class, "O"); IAtom o = container.getBuilder().newInstance(IAtom.class, "H"); container.addAtom(c1); container.addAtom(c2); container.addAtom(o); Assert.assertNotNull(container.getAtom(0)); Assert.assertEquals("C", container.getAtom(0).getSymbol()); }
@SuppressWarnings("unchecked") private Iterator<IAtom> atoms() { if (stack[sptr].iter == null) stack[sptr].iter = mol.atoms().iterator(); return stack[sptr].iter; }
@Test public void testCloneButKeepOriginalsIntact() throws Exception { IAtomContainer molecule = (IAtomContainer) newChemObject(); IAtom atom = molecule.getBuilder().newInstance(IAtom.class); molecule.addAtom(atom); Assert.assertEquals(atom, molecule.getAtom(0)); Object clone = molecule.clone(); Assert.assertNotSame(molecule, clone); // after the cloning the IAtom on the original IAtomContainer should be unchanged Assert.assertEquals(atom, molecule.getAtom(0)); }
private IAtomContainer makeButane() { IAtomContainer container = makeEthane(); container.addAtom(container.getBuilder().newInstance(IAtom.class, Elements.CARBON)); container.addAtom(container.getBuilder().newInstance(IAtom.class, Elements.CARBON)); container.addBond(1, 2, IBond.Order.SINGLE); container.addBond(2, 3, IBond.Order.SINGLE); return container; }
private void processAtomsBlock(int lineCount, IAtomContainer container) throws IOException { for (int i = 0; i < lineCount; i++) { String line = input.readLine(); int atomicNumber = Integer.parseInt(line.substring(7, 10).trim()); IAtom atom = container.getBuilder().newInstance(IAtom.class); atom.setAtomicNumber(atomicNumber); atom.setSymbol(PeriodicTable.getSymbol(atomicNumber)); container.addAtom(atom); } }