@Override public IChemObject newTestObject() { return new AtomContainer(); } });
/** * * Adds the atom oAtom to a specific Monomer. * * @param oAtom The atom to add * @param oMonomer The monomer the atom belongs to * */ @Override public void addAtom(IAtom oAtom, IMonomer oMonomer) { int atomCount = super.getAtomCount(); // Add atom to AtomContainer super.addAtom(oAtom); if (atomCount != super.getAtomCount()) { // ok, super did not yet contain the atom if (oMonomer == null) { oMonomer = getMonomer(""); } oMonomer.addAtom(oAtom); if (!monomers.containsKey(oMonomer.getMonomerName())) { monomers.put(oMonomer.getMonomerName(), oMonomer); } } }
/** * {@inheritDoc} */ @Override public void addBond(int atom1, int atom2, IBond.Order order) { IBond bond = getBuilder().newInstance(IBond.class, getAtom(atom1), getAtom(atom2), order); addBond(bond); /* * no notifyChanged() here because addBond(bond) does it already */ }
/** * {@inheritDoc} */ @Override public void removeAtom(int pos) { removeAtom(getAtom(pos)); }
/** * {@inheritDoc} */ @Override public void addElectronContainer(IElectronContainer electronContainer) { if (electronContainer instanceof IBond) this.addBond((IBond) electronContainer); if (electronContainer instanceof ILonePair) this.addLonePair((ILonePair) electronContainer); if (electronContainer instanceof ISingleElectron) this.addSingleElectron((ISingleElectron) electronContainer); }
@Test public void testIsIsomorph_IAtomContainer_IAtomContainer() throws Exception { AtomContainer ac1 = new AtomContainer(); ac1.addAtom(new Atom("C")); AtomContainer ac2 = new AtomContainer(); ac2.addAtom(new Atom("C")); Assert.assertTrue(uiTester.isIsomorph(ac1, ac2)); Assert.assertTrue(uiTester.isSubgraph(ac1, ac2)); }
@Test public void testConfigureAtoms_IAtomContainer() throws Exception { AtomContainer container = new org.openscience.cdk.AtomContainer(); container.addAtom(new Atom("C")); container.addAtom(new Atom("H")); container.addAtom(new Atom("N")); container.addAtom(new Atom("O")); container.addAtom(new Atom("F")); container.addAtom(new Atom("Cl")); Isotopes isofac = Isotopes.getInstance(); isofac.configureAtoms(container); for (int i = 0; i < container.getAtomCount(); i++) { Assert.assertTrue(0 < container.getAtom(i).getAtomicNumber()); } }
@Test public void testCountAtomPermutation() { AtomContainer ac = new AtomContainer(); ac.addAtom(new Atom("C")); ac.addAtom(new Atom("N")); ac.addAtom(new Atom("P")); ac.addAtom(new Atom("O")); ac.addAtom(new Atom("S")); ac.addAtom(new Atom("Br")); ac.addBond(0, 1, IBond.Order.SINGLE); ac.addBond(1, 2, IBond.Order.SINGLE); ac.addBond(2, 3, IBond.Order.SINGLE); ac.addBond(3, 4, IBond.Order.SINGLE); ac.addBond(4, 5, IBond.Order.SINGLE); AtomContainerAtomPermutor acap = new AtomContainerAtomPermutor(ac); int counter = 0; while (acap.hasNext()) { counter++; acap.next(); } Assert.assertEquals(719, counter); }
@Test public void testSingleOrDoubleFlag() throws Exception { AtomContainer mol = new AtomContainer(); IBond bond5 = new Bond(atom5, atom1); mol.addAtom(atom1); mol.addAtom(atom2); mol.addAtom(atom3); mol.addAtom(atom4); mol.addAtom(atom5); mol.addBond(bond1); mol.addBond(bond2); mol.addBond(bond3); mol.addBond(bond4); mol.addBond(bond5); if (mol.getAtom(i).getFlag(CDKConstants.SINGLE_OR_DOUBLE)) mol.setFlag(CDKConstants.SINGLE_OR_DOUBLE, true); Assert.assertTrue(mol.getAtom(0).getFlag(CDKConstants.SINGLE_OR_DOUBLE)); Assert.assertTrue(mol.getBond(0).getFlag(CDKConstants.SINGLE_OR_DOUBLE)); Assert.assertTrue(mol.getFlag(CDKConstants.SINGLE_OR_DOUBLE));
@Test public void testBondPermutation() { AtomContainer ac = new org.openscience.cdk.AtomContainer(); AtomContainer result; String bonds = new String(""); ac.addAtom(new Atom("C")); ac.addAtom(new Atom("N")); ac.addAtom(new Atom("P")); ac.addAtom(new Atom("O")); ac.addAtom(new Atom("S")); ac.addAtom(new Atom("Br")); ac.addBond(0, 1, IBond.Order.SINGLE); ac.addBond(1, 2, IBond.Order.DOUBLE); ac.addBond(2, 3, IBond.Order.TRIPLE); ac.addBond(3, 4, IBond.Order.QUADRUPLE); ac.addBond(4, 5, IBond.Order.SINGLE); // was 5.0 ! AtomContainerBondPermutor acap = new AtomContainerBondPermutor(ac); int counter = 0; while (acap.hasNext()) { counter++; bonds = ""; result = (AtomContainer) acap.next(); for (int f = 0; f < result.getBondCount(); f++) { bonds += result.getBond(f).getOrder(); } //logger.debug(bonds); } Assert.assertEquals(119, counter); }
if (molBytes == null) break; AtomContainer mol = new AtomContainer(); MDLV2000Reader mdl = new MDLV2000Reader(new ByteArrayInputStream(molBytes)); mdl.read(mol); CircularFingerprinter.FP[] validateFCFP = parseValidation(content.get(basefn + ".fcfp")); logger.info("FN=" + basefn + " MOL=" + mol.getAtomCount() + "," + mol.getBondCount() + " Requires ECFP=" + validateECFP.length + " FCFP=" + validateFCFP.length);
/** * Test generation of a reaction SMILES. I know, it's a stupid alchemic * reaction, but it serves its purpose. */ @Test public void testReactionSMILES() throws Exception { Reaction reaction = new Reaction(); AtomContainer methane = new AtomContainer(); methane.addAtom(new Atom("C")); reaction.addReactant(methane); IAtomContainer magic = new AtomContainer(); magic.addAtom(new PseudoAtom("magic")); reaction.addAgent(magic); IAtomContainer gold = new AtomContainer(); gold.addAtom(new Atom("Au")); reaction.addProduct(gold); methane.getAtom(0).setImplicitHydrogenCount(4); gold.getAtom(0).setImplicitHydrogenCount(0); SmilesGenerator sg = new SmilesGenerator(SmiFlavor.Generic); String smiles = sg.create(reaction); //logger.debug("Generated SMILES: " + smiles); Assert.assertEquals("C>*>[Au]", smiles); }
stringContent.append("AtomContainer("); stringContent.append(this.hashCode()); if (getAtomCount() > 0) { stringContent.append(", #A:").append(getAtomCount()); for (int i = 0; i < getAtomCount(); i++) { stringContent.append(", ").append(getAtom(i).toString()); if (getBondCount() > 0) { stringContent.append(", #B:").append(getBondCount()); for (int i = 0; i < getBondCount(); i++) { stringContent.append(", ").append(getBond(i).toString()); if (getLonePairCount() > 0) { stringContent.append(", #LP:").append(getLonePairCount()); for (int i = 0; i < getLonePairCount(); i++) { stringContent.append(", ").append(getLonePair(i).toString()); if (getSingleElectronCount() > 0) { stringContent.append(", #SE:").append(getSingleElectronCount()); for (int i = 0; i < getSingleElectronCount(); i++) { stringContent.append(", ").append(getSingleElectron(i).toString());
/** * {@inheritDoc} */ @Override public void removeAllElements() { removeAllElectronContainers(); for (int f = 0; f < getAtomCount(); f++) { getAtom(f).removeListener(this); } atoms = new IAtom[growArraySize]; atomCount = 0; stereoElements.clear(); notifyChanged(); }
/** * {@inheritDoc} */ @Override public IAtom getLastAtom() { return getAtomCount() > 0 ? (IAtom) atoms[getAtomCount() - 1] : null; }
/** * {@inheritDoc} */ @Override public void addAtom(IAtom atom) { logger.debug("Adding atom: ", atom); super.addAtom(atom); }
/** * {@inheritDoc} */ @Override public int getConnectedBondsCount(int idx) { final IAtom atom = getAtom(idx); int count = 0; for (int i = 0; i < bondCount; i++) { if (bonds[i].contains(atom)) ++count; } return count; }
/** * {@inheritDoc} */ @Override public void addBond(IBond bond) { logger.debug("Adding bond: ", bond); super.addBond(bond); }
@Test public void testNoConnections() { HydrogenPlacer hydrogenPlacer = new HydrogenPlacer(); AtomContainer container = new AtomContainer(); Atom atom = new Atom("C", new Point2d(0, 0)); container.addAtom(atom); hydrogenPlacer.placeHydrogens2D(container, atom, 1.5); }
/** * @cdk.bug 1875946 */ @Test public void testPreservingFormalCharge() throws Exception { AtomContainer mol = new AtomContainer(); mol.addAtom(new Atom(Elements.OXYGEN)); mol.getAtom(0).setFormalCharge(-1); mol.addAtom(new Atom(Elements.CARBON)); mol.addBond(0, 1, IBond.Order.SINGLE); addImplicitHydrogens(mol); SmilesGenerator generator = new SmilesGenerator(); generator.create(new AtomContainer(mol)); Assert.assertEquals(-1, mol.getAtom(0).getFormalCharge().intValue()); // mmm, that does not reproduce the bug findings yet :( }