/** * Utility method to add an {@link IChemObject} to an {@link IAtomContainer}. * * @param ac the {@link IAtomContainer} to add to * @param item the {@link IChemObject} to add */ protected void addToAtomContainer(IAtomContainer ac, IChemObject item) { if (item instanceof IAtomContainer) { ac.add((IAtomContainer) item); } else if (item instanceof IAtom) { ac.addAtom((IAtom) item); } else if (item instanceof IBond) { ac.addBond((IBond) item); } }
private IAtomContainer getAllInOneContainer(IRingSet ringSet) { IAtomContainer resultContainer = ringSet.getBuilder().newInstance(IAtomContainer.class); Iterator<IAtomContainer> containers = RingSetManipulator.getAllAtomContainers(ringSet).iterator(); while (containers.hasNext()) { resultContainer.add((IAtomContainer) containers.next()); } return resultContainer; }
@Test public void testAdd_IAtomContainer_LonePairs() { IAtomContainer mol = (IAtomContainer) newChemObject(); IAtom c1 = mol.getBuilder().newInstance(IAtom.class, "C"); mol.addAtom(c1); mol.addLonePair(0); IAtomContainer container = (IAtomContainer) newChemObject(); container.add(mol); Assert.assertEquals(1, container.getAtomCount()); Assert.assertEquals(1, container.getLonePairCount()); }
@Test public void testAdd_IAtomContainer_SingleElectrons() { IAtomContainer mol = (IAtomContainer) newChemObject(); IAtom c1 = mol.getBuilder().newInstance(IAtom.class, "C"); mol.addAtom(c1); mol.addSingleElectron(0); IAtomContainer container = (IAtomContainer) newChemObject(); container.add(mol); Assert.assertEquals(1, container.getAtomCount()); Assert.assertEquals(1, container.getSingleElectronCount()); }
public IBond addBond(IAtom fromAtom, IAtom toAtom, IBond.Stereo stereo, IBond.Order order) { IBond newBond = chemModel.getBuilder().newInstance(IBond.class,fromAtom, toAtom, order, stereo); IAtomContainer fromContainer = ChemModelManipulator .getRelevantAtomContainer(chemModel, fromAtom); IAtomContainer toContainer = ChemModelManipulator .getRelevantAtomContainer(chemModel, toAtom); // we need to check if this merges two atom containers or not if (fromContainer != toContainer) { fromContainer.add(toContainer); chemModel.getMoleculeSet().removeAtomContainer(toContainer); } fromContainer.addBond(newBond); updateAtom(newBond.getAtom(0)); updateAtom(newBond.getAtom(1)); structureChanged(); return newBond; }
@Test public void testAdd_IAtomContainer() { IAtomContainer acetone = (IAtomContainer) newChemObject(); IAtom c1 = acetone.getBuilder().newInstance(IAtom.class, "C"); IAtom c2 = acetone.getBuilder().newInstance(IAtom.class, "C"); IAtom o = acetone.getBuilder().newInstance(IAtom.class, "O"); IAtom c3 = acetone.getBuilder().newInstance(IAtom.class, "C"); acetone.addAtom(c1); acetone.addAtom(c2); acetone.addAtom(c3); acetone.addAtom(o); IBond b1 = acetone.getBuilder().newInstance(IBond.class, c1, c2, IBond.Order.SINGLE); IBond b2 = acetone.getBuilder().newInstance(IBond.class, c1, o, IBond.Order.DOUBLE); IBond b3 = acetone.getBuilder().newInstance(IBond.class, c1, c3, IBond.Order.SINGLE); acetone.addBond(b1); acetone.addBond(b2); acetone.addBond(b3); IAtomContainer container = (IAtomContainer) newChemObject(); container.add(acetone); Assert.assertEquals(4, container.getAtomCount()); Assert.assertEquals(3, container.getBondCount()); }
public RemoveAtomsAndBondsEdit(IChemModel chemModel, IAtomContainer undoRedoContainer, String type, IChemModelRelay chemModelRelay) { this.chemModel = chemModel; this.undoRedoContainer = undoRedoContainer; this.container = chemModel.getBuilder().newInstance(IAtomContainer.class); Iterator<IAtomContainer> containers = ChemModelManipulator.getAllAtomContainers(chemModel).iterator(); while (containers.hasNext()) { container.add((IAtomContainer)containers.next()); } this.type = type; this.chemModelRelay=chemModelRelay; }
/** * Puts all rings of a ringSet in a single atomContainer * * @param ringSet The ringSet to use * @return The produced atomContainer */ public static IAtomContainer getAllInOneContainer(IRingSet ringSet) { IAtomContainer resultContainer = ringSet.getBuilder().newInstance(IAtomContainer.class); Iterator<IAtomContainer> containers = RingSetManipulator.getAllAtomContainers(ringSet).iterator(); while (containers.hasNext()) { resultContainer.add(containers.next()); } return resultContainer; }
/** * Gets all atomcontainers of a chemodel in one AtomContainer. * * @param chemModel The chemodel * @return The result. */ public static IAtomContainer getAllAtomContainersInOne(IChemModel chemModel){ List<IAtomContainer> acs=ChemModelManipulator.getAllAtomContainers(chemModel); IAtomContainer allinone=chemModel.getBuilder().newInstance(IAtomContainer.class); for(int i=0;i<acs.size();i++){ allinone.add(acs.get(i)); } return allinone; }
public IAtomContainer getConnectedAtomContainer() { if (this.chemModel != null) { IAtomContainer ac = this.chemModel.getBuilder().newInstance(IAtomContainer.class); for (IAtomContainer other : ChemModelManipulator.getAllAtomContainers(chemModel)) { ac.add(other); } return ac; } return null; }
/** * two disconnected 2,2-dimethylpropanes */ private static IAtomContainer disconnected() { IAtomContainer container = simple(); container.add(simple()); return container; }
/** {@inheritDoc} */ @Override public <T extends IChemObject> T read(T object) throws CDKException { if (!(object instanceof IAtomContainer)) throw new CDKException("Only supported is reading of IAtomCOntainer objects."); IAtomContainer result = (IAtomContainer) object; // do the actual parsing Model model = ModelFactory.createDefaultModel(); model.read(input, "", "N3"); IAtomContainer mol = Convertor.model2Molecule(model, object.getBuilder()); result.add(mol); return (T) result; }
/** {@inheritDoc} */ @Override public <T extends IChemObject> T read(T object) throws CDKException { if (!(object instanceof IAtomContainer)) throw new CDKException("Only supported is reading of IAtomCOntainer objects."); IAtomContainer result = (IAtomContainer) object; // do the actual parsing Model model = ModelFactory.createDefaultModel(); model.read(input, "", "N3"); IAtomContainer mol = Convertor.model2Molecule(model, object.getBuilder()); result.add(mol); return (T) result; }
@Override public ValidationReport validateReaction(IReaction subject) { ValidationReport report = new ValidationReport(); IAtomContainer container1 = subject.getBuilder().newInstance(IAtomContainer.class); IAtomContainerSet reactants = subject.getReactants(); for (int i = 0; i < reactants.getAtomContainerCount(); i++) { container1.add(reactants.getAtomContainer(i)); } IAtomContainer container2 = subject.getBuilder().newInstance(IAtomContainer.class); IAtomContainerSet products = subject.getProducts(); for (int i = 0; i < products.getAtomContainerCount(); i++) { container2.add(products.getAtomContainer(i)); } report.addReport(validateAtomCountConservation(subject, container1, container2)); report.addReport(validateChargeConservation(subject, container1, container2)); return report; }
@Test public void testReadGz() throws Exception { String filename = "data/xyz/bf3.xyz.gz"; InputStream input = new BufferedInputStream(new GZIPInputStream(this.getClass().getClassLoader() .getResourceAsStream(filename))); // ok, if format ok, try instantiating a reader ISimpleChemObjectReader reader = factory.createReader(input); Assert.assertNotNull(reader); Assert.assertEquals(((IChemFormat) XYZFormat.getInstance()).getReaderClassName(), reader.getClass().getName()); // now try reading something from it IChemFile chemFile = (IChemFile) reader.read(new ChemFile()); IAtomContainer molecule = new AtomContainer(); for (IAtomContainer container : ChemFileManipulator.getAllAtomContainers(chemFile)) { molecule.add(container); } Assert.assertNotNull(molecule); Assert.assertEquals(4, molecule.getAtomCount()); }
@Test public void testReadGzWithGzipDetection() throws Exception { String filename = "data/xyz/bf3.xyz.gz"; InputStream input = this.getClass().getClassLoader().getResourceAsStream(filename); // ok, if format ok, try instantiating a reader ISimpleChemObjectReader reader = factory.createReader(input); Assert.assertNotNull(reader); Assert.assertEquals(((IChemFormat) XYZFormat.getInstance()).getReaderClassName(), reader.getClass().getName()); // now try reading something from it IChemFile chemFile = (IChemFile) reader.read(new ChemFile()); IAtomContainer molecule = new AtomContainer(); for (IAtomContainer container : ChemFileManipulator.getAllAtomContainers(chemFile)) { molecule.add(container); } Assert.assertNotNull(molecule); Assert.assertEquals(4, molecule.getAtomCount()); }
@Test public void testAtomContainerHandling() throws Exception { IAtomContainer water1 = someoneBringMeSomeWater(DefaultChemObjectBuilder.getInstance()); // creates an AtomContainer with the atoms / bonds from water1 IAtomContainer water2 = SilentChemObjectBuilder.getInstance().newAtomContainer(); water2.add(water1); IDescriptorResult v1 = descriptor.calculate(water1).getValue(); IDescriptorResult v2 = descriptor.calculate(water2).getValue(); String errorMessage = "(" + descriptor.getClass().toString() + ") The descriptor does not give the same results depending on " + "it being passed an IAtomContainer or an IAtomContainer."; assertEqualOutput(v1, v2, errorMessage); }
@Test public void testBenzene() throws Exception { String[] expectedTypes = {"C.sp2", "C.sp2", "C.sp2", "C.sp2", "C.sp2", "C.sp2"}; IAtomContainer molecule = new AtomContainer(); molecule.add(new Ring(6, "C")); for (IBond bond : molecule.bonds()) { bond.setFlag(CDKConstants.ISAROMATIC, true); } for (IAtom atom : molecule.atoms()) { atom.setImplicitHydrogenCount(1); } assertAtomTypes(testedAtomTypes, expectedTypes, molecule); }
@Test public void testBenzene_SingleOrDouble() throws Exception { String[] expectedTypes = {"C.sp2", "C.sp2", "C.sp2", "C.sp2", "C.sp2", "C.sp2"}; IAtomContainer molecule = new AtomContainer(); molecule.add(new Ring(6, "C")); for (IBond bond : molecule.bonds()) { bond.setOrder(IBond.Order.UNSET); bond.setFlag(CDKConstants.SINGLE_OR_DOUBLE, true); } for (IAtom atom : molecule.atoms()) { atom.setImplicitHydrogenCount(1); } assertAtomTypes(testedAtomTypes, expectedTypes, molecule); }
private void writeChemFile(IChemFile file) throws Exception { IAtomContainer bigPile = file.getBuilder().newInstance(IAtomContainer.class); for (IAtomContainer container : ChemFileManipulator.getAllAtomContainers(file)) { bigPile.add(container); if (container.getTitle() != null) { if (bigPile.getTitle() != null) bigPile.setTitle(bigPile.getTitle() + "; " + container.getTitle()); else bigPile.setTitle(container.getTitle()); } if (container.getProperty(CDKConstants.REMARK) != null) { if (bigPile.getProperty(CDKConstants.REMARK) != null) bigPile.setProperty(CDKConstants.REMARK, bigPile.getProperty(CDKConstants.REMARK) + "; " + container.getProperty(CDKConstants.REMARK)); else bigPile.setProperty(CDKConstants.REMARK, container.getProperty(CDKConstants.REMARK)); } } writeMolecule(bigPile); }