/** * Adds all atoms and electronContainers of a given atomcontainer to this container. * * @param atomContainer The atomcontainer to be added */ public void add(IAtomContainer atomContainer) { for (int f = 0; f < atomContainer.getAtomCount(); f++) { if (!contains(atomContainer.getAtom(f))) { addAtom(atomContainer.getAtom(f)); } } for (int f = 0; f < atomContainer.getBondCount(); f++) { if (!contains(atomContainer.getBond(f))) { addBond(atomContainer.getBond(f)); } } for (int f = 0; f < atomContainer.getLonePairCount(); f++) { if (!contains(atomContainer.getLonePair(f))) { addLonePair(atomContainer.getLonePair(f)); } } for (int f = 0; f < atomContainer.getSingleElectronCount(); f++) { if (!contains(atomContainer.getSingleElectron(f))) { addSingleElectron(atomContainer.getSingleElectron(f)); } } for (IStereoElement se : atomContainer.stereoElements()) stereoElements.add(se); notifyChanged(); }
/** * Constructs an AtomContainer with a copy of the atoms and electronContainers of another * AtomContainer (A shallow copy, i.e., with the same objects as in the original AtomContainer). * * @param container An AtomContainer to copy the atoms and electronContainers from */ public AtomContainer(IAtomContainer container) { this.atomCount = container.getAtomCount(); this.bondCount = container.getBondCount(); this.lonePairCount = container.getLonePairCount(); this.singleElectronCount = container.getSingleElectronCount(); this.atoms = new IAtom[this.atomCount]; this.bonds = new IBond[this.bondCount]; this.lonePairs = new ILonePair[this.lonePairCount]; this.singleElectrons = new ISingleElectron[this.singleElectronCount]; stereoElements = new HashSet<IStereoElement>(atomCount / 2); for (IStereoElement element : container.stereoElements()) { addStereoElement(element); } for (int f = 0; f < container.getAtomCount(); f++) { atoms[f] = container.getAtom(f); container.getAtom(f).addListener(this); } for (int f = 0; f < this.bondCount; f++) { bonds[f] = container.getBond(f); container.getBond(f).addListener(this); } for (int f = 0; f < this.lonePairCount; f++) { lonePairs[f] = container.getLonePair(f); container.getLonePair(f).addListener(this); } for (int f = 0; f < this.singleElectronCount; f++) { singleElectrons[f] = container.getSingleElectron(f); container.getSingleElectron(f).addListener(this); } }
/** * Removes all atoms and electronContainers of a given atomcontainer from this container. * * @param atomContainer The atomcontainer to be removed */ public void remove(IAtomContainer atomContainer) { for (int f = 0; f < atomContainer.getAtomCount(); f++) { removeAtom(atomContainer.getAtom(f)); } for (int f = 0; f < atomContainer.getBondCount(); f++) { removeBond(atomContainer.getBond(f)); } for (int f = 0; f < atomContainer.getLonePairCount(); f++) { removeLonePair(atomContainer.getLonePair(f)); } for (int f = 0; f < atomContainer.getSingleElectronCount(); f++) { removeSingleElectron(atomContainer.getSingleElectron(f)); } }
/** * A unit test for JUnit with C=CCCl # C=CC[Cl+*] * * @cdk.inchi InChI=1/C3H7Cl/c1-2-3-4/h2-3H2,1H3 */ @Test public void testCompareIonized() throws Exception { IAtomContainer molA = builder.newInstance(IAtomContainer.class); molA.addAtom(builder.newInstance(IAtom.class, "C")); molA.addAtom(builder.newInstance(IAtom.class, "C")); molA.addBond(0, 1, IBond.Order.SINGLE); molA.addAtom(builder.newInstance(IAtom.class, "C")); molA.addBond(1, 2, IBond.Order.SINGLE); molA.addAtom(builder.newInstance(IAtom.class, "Cl")); molA.addBond(2, 3, IBond.Order.SINGLE); addExplicitHydrogens(molA); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molA); lpcheck.saturate(molA); double resultA = ((DoubleResult) descriptor.calculate(molA.getAtom(3), molA).getValue()).doubleValue(); IAtomContainer molB = builder.newInstance(IAtomContainer.class); molB.addAtom(builder.newInstance(IAtom.class, "C")); molB.addAtom(builder.newInstance(IAtom.class, "C")); molB.addBond(0, 1, IBond.Order.SINGLE); molB.addAtom(builder.newInstance(IAtom.class, "C")); molB.addBond(1, 2, IBond.Order.SINGLE); molB.addAtom(builder.newInstance(IAtom.class, "Cl")); molB.getAtom(3).setFormalCharge(1); molB.addSingleElectron(3); molB.addLonePair(3); molB.addLonePair(3); molB.addBond(2, 3, IBond.Order.SINGLE); addExplicitHydrogens(molB); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molB); lpcheck.saturate(molB); Assert.assertEquals(1, molB.getAtom(3).getFormalCharge(), 0.00001); Assert.assertEquals(1, molB.getSingleElectronCount(), 0.00001); Assert.assertEquals(2, molB.getLonePairCount(), 0.00001); double resultB = ((DoubleResult) descriptor.calculate(molB.getAtom(3), molB).getValue()).doubleValue(); Assert.assertNotSame(resultA, resultB); }
/** * Get all paths of lengths 0 to the specified length. * * <p>This method will find all paths upto length N starting from each atom in the molecule and * return the unique set of such paths. * * @param container The molecule to search * @return A map of path strings, keyed on themselves */ private Integer[] findPaths(IAtomContainer container) { ShortestPathWalker walker = new ShortestPathWalker(container); // convert paths to hashes List<Integer> paths = new ArrayList<Integer>(); int patternIndex = 0; for (String s : walker.paths()) { int toHashCode = s.hashCode(); paths.add(patternIndex, toHashCode); patternIndex++; } /* * Add ring information */ IRingSet sssr = Cycles.essential(container).toRingSet(); RingSetManipulator.sort(sssr); for (Iterator<IAtomContainer> it = sssr.atomContainers().iterator(); it.hasNext(); ) { IAtomContainer ring = it.next(); int toHashCode = String.valueOf(ring.getAtomCount()).hashCode(); paths.add(patternIndex, toHashCode); patternIndex++; } /* * Check for the charges */ List<String> l = new ArrayList<String>(); for (Iterator<IAtom> it = container.atoms().iterator(); it.hasNext(); ) { IAtom atom = it.next(); int charge = atom.getFormalCharge() == null ? 0 : atom.getFormalCharge(); if (charge != 0) { l.add(atom.getSymbol().concat(String.valueOf(charge))); } } Collections.sort(l); int toHashCode = l.hashCode(); paths.add(patternIndex, toHashCode); patternIndex++; l = new ArrayList<String>(); /* * atom stereo parity */ for (Iterator<IAtom> it = container.atoms().iterator(); it.hasNext(); ) { IAtom atom = it.next(); int st = atom.getStereoParity() == null ? 0 : atom.getStereoParity(); if (st != 0) { l.add(atom.getSymbol().concat(String.valueOf(st))); } } Collections.sort(l); toHashCode = l.hashCode(); paths.add(patternIndex, toHashCode); patternIndex++; if (container.getSingleElectronCount() > 0) { StringBuilder radicalInformation = new StringBuilder(); radicalInformation.append("RAD: ").append(String.valueOf(container.getSingleElectronCount())); paths.add(patternIndex, radicalInformation.toString().hashCode()); patternIndex++; } if (container.getLonePairCount() > 0) { StringBuilder lpInformation = new StringBuilder(); lpInformation.append("LP: ").append(String.valueOf(container.getLonePairCount())); paths.add(patternIndex, lpInformation.toString().hashCode()); patternIndex++; } return paths.toArray(new Integer[paths.size()]); }