/** * calculates the kier shape indices for an atom container * * @param container AtomContainer * @return kier1, kier2 and kier3 are returned as arrayList of doubles * @throws CDKException Possible Exceptions */ @Override public DescriptorValue calculate(IAtomContainer container) { IAtomContainer atomContainer; try { atomContainer = (IAtomContainer) container.clone(); } catch (CloneNotSupportedException e) { DoubleArrayResult kierValues = new DoubleArrayResult(3); kierValues.add(Double.NaN); kierValues.add(Double.NaN); kierValues.add(Double.NaN); return new DescriptorValue( getSpecification(), getParameterNames(), getParameters(), kierValues, getDescriptorNames()); } atomContainer = AtomContainerManipulator.removeHydrogens(atomContainer); // org.openscience.cdk.interfaces.IAtom[] atoms = atomContainer.getAtoms(); java.util.List firstAtomNeighboors; java.util.List secondAtomNeighboors; java.util.List thirdAtomNeighboors; DoubleArrayResult kierValues = new DoubleArrayResult(3); double bond1; double bond2; double bond3; double kier1; double kier2; double kier3; double atomsCount = atomContainer.getAtomCount(); ArrayList<Double> singlePaths = new ArrayList<Double>(); ArrayList<String> doublePaths = new ArrayList<String>(); ArrayList<String> triplePaths = new ArrayList<String>(); double[] sorterFirst = new double[2]; double[] sorterSecond = new double[3]; String tmpbond2; String tmpbond3; for (int a1 = 0; a1 < atomsCount; a1++) { bond1 = 0; firstAtomNeighboors = atomContainer.getConnectedAtomsList(atomContainer.getAtom(a1)); for (int a2 = 0; a2 < firstAtomNeighboors.size(); a2++) { bond1 = atomContainer.getBondNumber( atomContainer.getAtom(a1), (IAtom) firstAtomNeighboors.get(a2)); if (!singlePaths.contains(new Double(bond1))) { singlePaths.add(bond1); java.util.Collections.sort(singlePaths); } secondAtomNeighboors = atomContainer.getConnectedAtomsList((IAtom) firstAtomNeighboors.get(a2)); for (int a3 = 0; a3 < secondAtomNeighboors.size(); a3++) { bond2 = atomContainer.getBondNumber( (IAtom) firstAtomNeighboors.get(a2), (IAtom) secondAtomNeighboors.get(a3)); if (!singlePaths.contains(new Double(bond2))) { singlePaths.add(bond2); } sorterFirst[0] = bond1; sorterFirst[1] = bond2; java.util.Arrays.sort(sorterFirst); tmpbond2 = sorterFirst[0] + "+" + sorterFirst[1]; if (!doublePaths.contains(tmpbond2) && (bond1 != bond2)) { doublePaths.add(tmpbond2); } thirdAtomNeighboors = atomContainer.getConnectedAtomsList((IAtom) secondAtomNeighboors.get(a3)); for (int a4 = 0; a4 < thirdAtomNeighboors.size(); a4++) { bond3 = atomContainer.getBondNumber( (IAtom) secondAtomNeighboors.get(a3), (IAtom) thirdAtomNeighboors.get(a4)); if (!singlePaths.contains(new Double(bond3))) { singlePaths.add(bond3); } sorterSecond[0] = bond1; sorterSecond[1] = bond2; sorterSecond[2] = bond3; java.util.Arrays.sort(sorterSecond); tmpbond3 = sorterSecond[0] + "+" + sorterSecond[1] + "+" + sorterSecond[2]; if (!triplePaths.contains(tmpbond3)) { if ((bond1 != bond2) && (bond1 != bond3) && (bond2 != bond3)) { triplePaths.add(tmpbond3); } } } } } } if (atomsCount == 1) { kier1 = 0; kier2 = 0; kier3 = 0; } else { kier1 = (((atomsCount) * ((atomsCount - 1) * (atomsCount - 1))) / (singlePaths.size() * singlePaths.size())); if (atomsCount == 2) { kier2 = 0; kier3 = 0; } else { if (doublePaths.size() == 0) kier2 = Double.NaN; else kier2 = (((atomsCount - 1) * ((atomsCount - 2) * (atomsCount - 2))) / (doublePaths.size() * doublePaths.size())); if (atomsCount == 3) { kier3 = 0; } else { if (atomsCount % 2 != 0) { if (triplePaths.size() == 0) kier3 = Double.NaN; else kier3 = (((atomsCount - 1) * ((atomsCount - 3) * (atomsCount - 3))) / (triplePaths.size() * triplePaths.size())); } else { if (triplePaths.size() == 0) kier3 = Double.NaN; else kier3 = (((atomsCount - 3) * ((atomsCount - 2) * (atomsCount - 2))) / (triplePaths.size() * triplePaths.size())); } } } } kierValues.add(kier1); kierValues.add(kier2); kierValues.add(kier3); return new DescriptorValue( getSpecification(), getParameterNames(), getParameters(), kierValues, getDescriptorNames()); }
/** * 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; }
/** * This makes sourceAtom map1 of matching atoms out of sourceAtom map1 of matching bonds as * produced by the get(Subgraph|Ismorphism)Map methods. * * @param rMapList The list produced by the getMap method. * @param graph1 first molecule. Must not be an IQueryAtomContainer. * @param graph2 second molecule. May be an IQueryAtomContainer. * @return The mapping found projected on graph1. This is sourceAtom List of CDKRMap objects * containing Ids of matching atoms. */ private synchronized List<List<CDKRMap>> makeAtomsMapOfBondsMap( List<CDKRMap> rMapList, IAtomContainer graph1, IAtomContainer graph2) { if (rMapList == null) { return (null); } List<List<CDKRMap>> result; if (rMapList.size() == 1) { result = makeAtomsMapOfBondsMapSingleBond(rMapList, graph1, graph2); } else { List<CDKRMap> resultLocal = new ArrayList<CDKRMap>(); for (CDKRMap rMapList2 : rMapList) { IBond qBond = graph1.getBond(rMapList2.getId1()); IBond tBond = graph2.getBond(rMapList2.getId2()); IAtom[] qAtoms = BondManipulator.getAtomArray(qBond); IAtom[] tAtoms = BondManipulator.getAtomArray(tBond); for (int j = 0; j < 2; j++) { List<IBond> bondsConnectedToAtom1j = graph1.getConnectedBondsList(qAtoms[j]); for (IBond bondsConnectedToAtom1j1 : bondsConnectedToAtom1j) { if (bondsConnectedToAtom1j1 != qBond) { IBond testBond = bondsConnectedToAtom1j1; for (CDKRMap rMapList1 : rMapList) { IBond testBond2; if ((rMapList1).getId1() == graph1.getBondNumber(testBond)) { testBond2 = graph2.getBond((rMapList1).getId2()); for (int n = 0; n < 2; n++) { List<IBond> bondsToTest = graph2.getConnectedBondsList(tAtoms[n]); if (bondsToTest.contains(testBond2)) { CDKRMap map1; if (j == n) { map1 = new CDKRMap( graph1.getAtomNumber(qAtoms[0]), graph2.getAtomNumber(tAtoms[0])); } else { map1 = new CDKRMap( graph1.getAtomNumber(qAtoms[1]), graph2.getAtomNumber(tAtoms[0])); } if (!resultLocal.contains(map1)) { resultLocal.add(map1); } CDKRMap map2; if (j == n) { map2 = new CDKRMap( graph1.getAtomNumber(qAtoms[1]), graph2.getAtomNumber(tAtoms[1])); } else { map2 = new CDKRMap( graph1.getAtomNumber(qAtoms[0]), graph2.getAtomNumber(tAtoms[1])); } if (!resultLocal.contains(map2)) { resultLocal.add(map2); } } } } } } } } } result = new ArrayList<>(); result.add(resultLocal); } return result; }