private static void removeDuplicateAtomContainers(final IChemModel chemModel) { // we remove molecules which are in AtomContainerSet as well as in a // reaction final IReactionSet reactionSet = chemModel.getReactionSet(); final IAtomContainerSet moleculeSet = chemModel.getMoleculeSet(); if (reactionSet != null && moleculeSet != null) { final List<IAtomContainer> aclist = ReactionSetManipulator .getAllAtomContainers(reactionSet); for (int i = moleculeSet.getAtomContainerCount() - 1; i >= 0; i--) { for (int k = 0; k < aclist.size(); k++) { final String label = moleculeSet.getAtomContainer(i) .getID(); if (aclist.get(k).getID().equals(label)) { chemModel.getMoleculeSet().removeAtomContainer(i); break; } } } } }
/** * Initiate process. It is needed to call the addExplicitHydrogensToSatisfyValency from the class * tools.HydrogenAdder. * * @exception CDKException Description of the Exception * @param reactants reactants of the reaction. * @param agents agents of the reaction (Must be in this case null). */ @TestMethod("testInitiate_IAtomContainerSet_IAtomContainerSet") public IReactionSet initiate(IAtomContainerSet reactants, IAtomContainerSet agents) throws CDKException { logger.debug("initiate reaction: RearrangementRadicalReaction"); if (reactants.getAtomContainerCount() != 1) { throw new CDKException("RearrangementRadicalReaction only expects one reactant"); } if (agents != null) { throw new CDKException("RearrangementRadicalReaction don't expects agents"); } IReactionSet setOfReactions = DefaultChemObjectBuilder.getInstance().newInstance(IReactionSet.class); IAtomContainer reactant = reactants.getAtomContainer(0); /* if the parameter hasActiveCenter is not fixed yet, set the active centers*/ IParameterReact ipr = super.getParameterClass(SetReactionCenter.class); if (ipr != null && !ipr.isSetParameter()) setActiveCenters(reactant); Iterator<IAtom> atoms = reactants.getAtomContainer(0).atoms().iterator(); while (atoms.hasNext()) { IAtom atomi = atoms.next(); if (atomi.getFlag(CDKConstants.REACTIVE_CENTER) && reactant.getConnectedSingleElectronsCount(atomi) == 1) { Iterator<IBond> bondis = reactant.getConnectedBondsList(atomi).iterator(); while (bondis.hasNext()) { IBond bondi = bondis.next(); if (bondi.getFlag(CDKConstants.REACTIVE_CENTER) && bondi.getOrder() == IBond.Order.SINGLE) { IAtom atomj = bondi.getConnectedAtom(atomi); if (atomi.getFlag(CDKConstants.REACTIVE_CENTER) && (atomj.getFormalCharge() == CDKConstants.UNSET ? 0 : atomj.getFormalCharge()) == 0 && reactant.getConnectedSingleElectronsCount(atomj) == 0) { Iterator<IBond> bondjs = reactant.getConnectedBondsList(atomj).iterator(); while (bondjs.hasNext()) { IBond bondj = bondjs.next(); if (bondj.equals(bondi)) continue; if (bondj.getFlag(CDKConstants.REACTIVE_CENTER) && bondj.getOrder() == IBond.Order.DOUBLE) { IAtom atomk = bondj.getConnectedAtom(atomj); if (atomk.getFlag(CDKConstants.REACTIVE_CENTER) && (atomk.getFormalCharge() == CDKConstants.UNSET ? 0 : atomk.getFormalCharge()) == 0 && reactant.getConnectedSingleElectronsCount(atomk) == 0) { ArrayList<IAtom> atomList = new ArrayList<IAtom>(); atomList.add(atomi); atomList.add(atomj); atomList.add(atomk); ArrayList<IBond> bondList = new ArrayList<IBond>(); bondList.add(bondi); bondList.add(bondj); IAtomContainerSet moleculeSet = reactant.getBuilder().newInstance(IAtomContainerSet.class); moleculeSet.addAtomContainer(reactant); IReaction reaction = mechanism.initiate(moleculeSet, atomList, bondList); if (reaction == null) continue; else setOfReactions.addReaction(reaction); } } } } } } } } return setOfReactions; }
private static void removeEmptyAtomContainers(final IChemModel chemModel) { final IAtomContainerSet moleculeSet = chemModel.getMoleculeSet(); if (moleculeSet != null && moleculeSet.getAtomContainerCount() == 0) { chemModel.setMoleculeSet(null); } }
/** * Initiates the process for the given mechanism. The atoms to apply are mapped between reactants * and products. * * @param atomContainerSet * @param atomList The list of atoms taking part in the mechanism. Only allowed two atoms. The * first atom is the atom which contains the ISingleElectron and the second third is the atom * which will be removed the first atom * @param bondList The list of bonds taking part in the mechanism. Only allowed one bond. It is * the bond which is moved * @return The Reaction mechanism */ @TestMethod(value = "testInitiate_IAtomContainerSet_ArrayList_ArrayList") public IReaction initiate( IAtomContainerSet atomContainerSet, ArrayList<IAtom> atomList, ArrayList<IBond> bondList) throws CDKException { CDKAtomTypeMatcher atMatcher = CDKAtomTypeMatcher.getInstance(atomContainerSet.getBuilder()); if (atomContainerSet.getAtomContainerCount() != 1) { throw new CDKException("RadicalSiteIonizationMechanism only expects one IMolecule"); } if (atomList.size() != 3) { throw new CDKException("RadicalSiteIonizationMechanism expects three atoms in the ArrayList"); } if (bondList.size() != 2) { throw new CDKException( "RadicalSiteIonizationMechanism only expect one bond in the ArrayList"); } IAtomContainer molecule = atomContainerSet.getAtomContainer(0); IAtomContainer reactantCloned; try { reactantCloned = (IAtomContainer) molecule.clone(); } catch (CloneNotSupportedException e) { throw new CDKException("Could not clone IMolecule!", e); } IAtom atom1 = atomList.get(0); // Atom containing the ISingleElectron IAtom atom1C = reactantCloned.getAtom(molecule.getAtomNumber(atom1)); IAtom atom2 = atomList.get(1); // Atom IAtom atom2C = reactantCloned.getAtom(molecule.getAtomNumber(atom2)); IAtom atom3 = atomList.get(2); // Atom to be saved IAtom atom3C = reactantCloned.getAtom(molecule.getAtomNumber(atom3)); IBond bond1 = bondList.get(0); // Bond to increase the order int posBond1 = molecule.getBondNumber(bond1); IBond bond2 = bondList.get(1); // Bond to remove int posBond2 = molecule.getBondNumber(bond2); BondManipulator.increaseBondOrder(reactantCloned.getBond(posBond1)); reactantCloned.removeBond(reactantCloned.getBond(posBond2)); List<ISingleElectron> selectron = reactantCloned.getConnectedSingleElectronsList(atom1C); reactantCloned.removeSingleElectron(selectron.get(selectron.size() - 1)); atom1C.setHybridization(null); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(reactantCloned); IAtomType type = atMatcher.findMatchingAtomType(reactantCloned, atom1C); if (type == null) return null; atom2C.setHybridization(null); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(reactantCloned); type = atMatcher.findMatchingAtomType(reactantCloned, atom2C); if (type == null) return null; reactantCloned.addSingleElectron(new SingleElectron(atom3C)); atom3C.setHybridization(null); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(reactantCloned); type = atMatcher.findMatchingAtomType(reactantCloned, atom3C); if (type == null) return null; IReaction reaction = DefaultChemObjectBuilder.getInstance().newInstance(IReaction.class); reaction.addReactant(molecule); /* mapping */ for (IAtom atom : molecule.atoms()) { IMapping mapping = DefaultChemObjectBuilder.getInstance() .newInstance( IMapping.class, atom, reactantCloned.getAtom(molecule.getAtomNumber(atom))); reaction.addMapping(mapping); } IAtomContainerSet moleculeSetP = ConnectivityChecker.partitionIntoMolecules(reactantCloned); for (int z = 0; z < moleculeSetP.getAtomContainerCount(); z++) reaction.addProduct((IAtomContainer) moleculeSetP.getAtomContainer(z)); return reaction; }
/** * Search if the setOfAtomContainer contains the atomContainer * * @param set ISetOfAtomContainer object where to search * @param atomContainer IAtomContainer to search * @return True, if the atomContainer is contained */ private boolean existAC(IAtomContainerSet set, IAtomContainer atomContainer) { IAtomContainer acClone = null; try { acClone = (IMolecule) atomContainer.clone(); if (!lookingSymmetry) { /*remove all aromatic flags*/ for (IAtom atom : acClone.atoms()) atom.setFlag(CDKConstants.ISAROMATIC, false); for (IBond bond : acClone.bonds()) bond.setFlag(CDKConstants.ISAROMATIC, false); } } catch (CloneNotSupportedException e1) { e1.printStackTrace(); } for (int i = 0; i < acClone.getAtomCount(); i++) // if(acClone.getAtom(i).getID() == null) acClone.getAtom(i).setID("" + acClone.getAtomNumber(acClone.getAtom(i))); if (lookingSymmetry) { try { CDKHueckelAromaticityDetector.detectAromaticity(acClone); } catch (CDKException e) { e.printStackTrace(); } } else { if (!lookingSymmetry) { /*remove all aromatic flags*/ for (IAtom atom : acClone.atoms()) atom.setFlag(CDKConstants.ISAROMATIC, false); for (IBond bond : acClone.bonds()) bond.setFlag(CDKConstants.ISAROMATIC, false); } } for (int i = 0; i < set.getAtomContainerCount(); i++) { IAtomContainer ss = set.getAtomContainer(i); for (int j = 0; j < ss.getAtomCount(); j++) // if(ss.getAtom(j).getID() == null) ss.getAtom(j).setID("" + ss.getAtomNumber(ss.getAtom(j))); try { if (!lookingSymmetry) { QueryAtomContainer qAC = QueryAtomContainerCreator.createSymbolChargeIDQueryContainer(acClone); if (UniversalIsomorphismTester.isIsomorph(ss, qAC)) { QueryAtomContainer qAC2 = QueryAtomContainerCreator.createSymbolAndBondOrderQueryContainer(acClone); if (UniversalIsomorphismTester.isIsomorph(ss, qAC2)) return true; } } else { QueryAtomContainer qAC = QueryAtomContainerCreator.createSymbolAndChargeQueryContainer(acClone); CDKHueckelAromaticityDetector.detectAromaticity(ss); if (UniversalIsomorphismTester.isIsomorph(ss, qAC)) return true; } } catch (CDKException e1) { System.err.println(e1); logger.error(e1.getMessage()); logger.debug(e1); } } return false; }