/** * @param list * @param source * @param target */ protected synchronized void identifySingleAtomsMatchedParts( List<CDKRMap> list, IAtomContainer source, IAtomContainer target) { // List<IAtom> array1 = new ArrayList<>(); // List<IAtom> array2 = new ArrayList<>(); /* We have serial numbers of the bonds/Atoms to delete * Now we will collect the actual bond/Atoms rather than * serial number for deletion. RonP flag check whether reactant is * mapped on product or Vise Versa */ TreeMap<Integer, Integer> atomNumbersFromContainer = new TreeMap<>(); for (CDKRMap rmap : list) { // System.err.print("Map " + o.getClass()); IAtom sAtom = source.getAtom(rmap.getId1()); IAtom tAtom = target.getAtom(rmap.getId2()); // array1.add(sAtom); // array2.add(tAtom); int indexI = source.getAtomNumber(sAtom); int indexJ = target.getAtomNumber(tAtom); atomNumbersFromContainer.put(indexI, indexJ); /*Added the Mapping Numbers to the FinalMapping* */ getMappings().add(atomNumbersFromContainer); } }
/** * Generate Compatibility Graph Nodes * * @return * @throws IOException */ private int compatibilityGraphNodes() throws IOException { compGraphNodes.clear(); Set<Edge> edges = new HashSet<>(); int nodeCount = 1; Map<IAtom, List<String>> labelAtomsBySymbolA = labelAtomsBySymbol(source); Map<IAtom, List<String>> labelAtomsBySymbolB = labelAtomsBySymbol(target); for (Map.Entry<IAtom, List<String>> labelA : labelAtomsBySymbolA.entrySet()) { // System.err.println("labelA.getValue() " + labelA.getValue()); for (Map.Entry<IAtom, List<String>> labelB : labelAtomsBySymbolB.entrySet()) { IAtom atom = labelA.getKey(); if (((atom instanceof IQueryAtom) && ((IQueryAtom) atom).matches(labelB.getKey())) || (!(atom instanceof IQueryAtom) && atom.getSymbol().equals(labelB.getKey().getSymbol()))) { // System.err.println("labelB.getValue() " + labelB.getValue()); int atomNumberI = source.getAtomNumber(labelA.getKey()); int atomNumberJ = target.getAtomNumber(labelB.getKey()); Edge e = new Edge(atomNumberI, atomNumberJ); if (!edges.contains(e)) { edges.add(e); compGraphNodes.add(atomNumberI); compGraphNodes.add(atomNumberJ); compGraphNodes.add(nodeCount); nodeCount += 1; } } } } return 0; }
/** * Fill the {@literal coordinates} and {@literal elevation} from the given offset index. If there * is only one connection then the second entry (from the offset) will use the coordinates of * <i>a</i>. The permutation parity is also built and returned. * * @param container atom container * @param a the central atom * @param connected bonds connected to the central atom * @param coordinates the coordinates array to fill * @param elevations the elevations of the connected atoms * @param offset current location in the offset array * @return the permutation parity */ private static PermutationParity fill2DCoordinates( IAtomContainer container, IAtom a, List<IBond> connected, Point2d[] coordinates, int[] elevations, int offset) { int i = 0; coordinates[offset + 1] = a.getPoint2d(); elevations[offset + 1] = 0; int[] indices = new int[2]; for (IBond bond : connected) { if (!isDoubleBond(bond)) { IAtom other = bond.getConnectedAtom(a); coordinates[i + offset] = other.getPoint2d(); elevations[i + offset] = elevation(bond, a); indices[i] = container.getAtomNumber(other); i++; } } if (i == 1) { return PermutationParity.IDENTITY; } else { return new BasicPermutationParity(indices); } }
public static IAtomContainer getMcsAsNewContainer(IAtomContainer mol1, IAtomContainer mol2) throws CDKException, CloneNotSupportedException { Isomorphism mcs = new Isomorphism(org.openscience.cdk.smsd.interfaces.Algorithm.DEFAULT, true); mcs.init(mol1, mol2, true, true); mcs.setChemFilters(true, true, true); mol1 = mcs.getReactantMolecule(); mol2 = mcs.getProductMolecule(); IAtomContainer mcsmolecule = DefaultChemObjectBuilder.getInstance().newInstance(IAtomContainer.class, mol1); List<IAtom> atomsToBeRemoved = new ArrayList<IAtom>(); for (IAtom atom : mcsmolecule.atoms()) { int index = mcsmolecule.getAtomNumber(atom); if (!mcs.getFirstMapping().containsKey(index)) { atomsToBeRemoved.add(atom); } } for (IAtom atom : atomsToBeRemoved) { mcsmolecule.removeAtomAndConnectedElectronContainers(atom); } return mcsmolecule; }
/** * Convenience method for giving a string representation of this ring based on the number of the * atom in a given molecule. * * @param molecule A molecule to determine an atom number for each ring atom * @return string representation of this ring */ private String toString(IRing ring, IAtomContainer molecule) throws Exception { String str = ""; for (int f = 0; f < ring.getAtomCount(); f++) { str += molecule.getAtomNumber(ring.getAtom(f)) + " - "; } return str; }
@Override public int seed(IAtomContainer molecule, IAtom atom, BitSet mask) { double sum = 0; for (IBond bond : molecule.getConnectedBondsList(atom)) { if (mask.get(molecule.getAtomNumber(bond.getConnectedAtom(atom)))) sum += order(bond.getOrder()); } return ((Double) sum).hashCode(); }
/** * Create an encoder for axial 3D stereochemistry for the given start and end atoms. * * @param container the molecule * @param start start of the cumulated system * @param startBonds bonds connected to the start * @param end end of the cumulated system * @param endBonds bonds connected to the end * @return an encoder */ private static StereoEncoder axial3DEncoder( IAtomContainer container, IAtom start, List<IBond> startBonds, IAtom end, List<IBond> endBonds) { Point3d[] coordinates = new Point3d[4]; PermutationParity perm = new CombinedPermutationParity( fill3DCoordinates(container, start, startBonds, coordinates, 0), fill3DCoordinates(container, end, endBonds, coordinates, 2)); GeometricParity geom = new Tetrahedral3DParity(coordinates); int u = container.getAtomNumber(start); int v = container.getAtomNumber(end); return new GeometryEncoder(new int[] {u, v}, perm, geom); }
protected void process( IAtomContainer target, List<Integer> unmapped_atoms_molB, int mappingSize, List<Integer> i_bond_setB, List<String> c_bond_setB, List<Integer> mapped_atoms, int counter) { int unmapped_numB = unmapped_atoms_molB.size(); boolean bond_considered = false; boolean normal_bond = true; for (int atomIndex = 0; atomIndex < target.getBondCount(); atomIndex++) { Integer indexI = target.getAtomNumber(target.getBond(atomIndex).getAtom(0)); Integer indexJ = target.getAtomNumber(target.getBond(atomIndex).getAtom(1)); IBond bond = target.getBond(atomIndex); Integer order = (bond.getOrder().ordinal() + 1); for (int b = 0; b < unmapped_numB; b++) { if (unmapped_atoms_molB.get(b).equals(indexI)) { normal_bond = unMappedAtomsEqualsIndexI( target, mappingSize, atomIndex, counter, mapped_atoms, indexI, indexJ, order); bond_considered = true; } else if (unmapped_atoms_molB.get(b) == indexJ) { normal_bond = unMappedAtomsEqualsIndexJ( target, mappingSize, atomIndex, counter, mapped_atoms, indexI, indexJ, order); bond_considered = true; } if (normal_bond && bond_considered) { markNormalBonds(atomIndex, i_bond_setB, c_bond_setB, indexI, indexJ, order); normal_bond = true; break; } } bond_considered = false; } }
/** * Positions the aliphatic substituents of a ring system * * @param rs The RingSystem for which the substituents are to be laid out * @return A list of atoms that where laid out */ public IAtomContainer placeRingSubstituents(IRingSet rs, double bondLength) { logger.debug("RingPlacer.placeRingSubstituents() start"); IRing ring = null; IAtom atom = null; IRingSet rings = null; IAtomContainer unplacedPartners = rs.getBuilder().newInstance(IAtomContainer.class); IAtomContainer sharedAtoms = rs.getBuilder().newInstance(IAtomContainer.class); IAtomContainer primaryAtoms = rs.getBuilder().newInstance(IAtomContainer.class); IAtomContainer treatedAtoms = rs.getBuilder().newInstance(IAtomContainer.class); Point2d centerOfRingGravity = null; for (int j = 0; j < rs.getAtomContainerCount(); j++) { ring = (IRing) rs.getAtomContainer(j); /* Get the j-th Ring in RingSet rs */ for (int k = 0; k < ring.getAtomCount(); k++) { unplacedPartners.removeAllElements(); sharedAtoms.removeAllElements(); primaryAtoms.removeAllElements(); atom = ring.getAtom(k); rings = rs.getRings(atom); centerOfRingGravity = GeometryTools.get2DCenter(rings); atomPlacer.partitionPartners(atom, unplacedPartners, sharedAtoms); atomPlacer.markNotPlaced(unplacedPartners); try { for (int f = 0; f < unplacedPartners.getAtomCount(); f++) { logger.debug( "placeRingSubstituents->unplacedPartners: " + (molecule.getAtomNumber(unplacedPartners.getAtom(f)) + 1)); } } catch (Exception exc) { } treatedAtoms.add(unplacedPartners); if (unplacedPartners.getAtomCount() > 0) { atomPlacer.distributePartners( atom, sharedAtoms, centerOfRingGravity, unplacedPartners, bondLength); } } } logger.debug("RingPlacer.placeRingSubstituents() end"); return treatedAtoms; }
/** * The method calculates the sigma electronegativity of a given atom It is needed to call the * addExplicitHydrogensToSatisfyValency method from the class tools.HydrogenAdder. * * @param atom The IAtom for which the DescriptorValue is requested * @param ac AtomContainer * @return return the sigma electronegativity */ @TestMethod(value = "testCalculate_IAtomContainer") public DescriptorValue calculate(IAtom atom, IAtomContainer ac) { IAtomContainer clone; IAtom localAtom; try { clone = (IAtomContainer) ac.clone(); localAtom = clone.getAtom(ac.getAtomNumber(atom)); AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(clone); } catch (CDKException e) { return new DescriptorValue( getSpecification(), getParameterNames(), getParameters(), new DoubleResult(Double.NaN), descriptorNames, e); } catch (CloneNotSupportedException e) { return new DescriptorValue( getSpecification(), getParameterNames(), getParameters(), new DoubleResult(Double.NaN), descriptorNames, e); } if (maxIterations != -1 && maxIterations != 0) electronegativity.setMaxIterations(maxIterations); double result = electronegativity.calculateSigmaElectronegativity(clone, localAtom); return new DescriptorValue( getSpecification(), getParameterNames(), getParameters(), new DoubleResult(result), descriptorNames); }
private List<List<Integer>> getAtomMappings(List bondMapping, IAtomContainer atomContainer) { List<List<Integer>> atomMapping = new ArrayList<List<Integer>>(); // loop over each mapping for (Object aBondMapping : bondMapping) { List list = (List) aBondMapping; List<Integer> tmp = new ArrayList<Integer>(); IAtom atom1 = null; IAtom atom2 = null; // loop over this mapping for (Object aList : list) { RMap map = (RMap) aList; int bondID = map.getId1(); // get the atoms in this bond IBond bond = atomContainer.getBond(bondID); atom1 = bond.getAtom(0); atom2 = bond.getAtom(1); Integer idx1 = atomContainer.getAtomNumber(atom1); Integer idx2 = atomContainer.getAtomNumber(atom2); if (!tmp.contains(idx1)) tmp.add(idx1); if (!tmp.contains(idx2)) tmp.add(idx2); } if (tmp.size() > 0) atomMapping.add(tmp); // If there is only one bond, check if it matches both ways. if (list.size() == 1 && atom1.getAtomicNumber() == atom2.getAtomicNumber()) { List<Integer> tmp2 = new ArrayList<Integer>(); tmp2.add(tmp.get(0)); tmp2.add(tmp.get(1)); atomMapping.add(tmp2); } } return atomMapping; }
/** * 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; }
/** * 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; }
/** * Generated coordinates for a given ring, which is fused to another ring. The rings share exactly * one bond. * * @param ring The ring to be placed * @param sharedAtoms The atoms of this ring, also members of another ring, which are already * placed * @param sharedAtomsCenter The geometric center of these atoms * @param ringCenterVector A vector pointing the the center of the new ring * @param bondLength The standard bondlength */ public void placeFusedRing( IRing ring, IAtomContainer sharedAtoms, Point2d sharedAtomsCenter, Vector2d ringCenterVector, double bondLength) { logger.debug("RingPlacer.placeFusedRing() start"); Point2d ringCenter = new Point2d(sharedAtomsCenter); double radius = getNativeRingRadius(ring, bondLength); double newRingPerpendicular = Math.sqrt(Math.pow(radius, 2) - Math.pow(bondLength / 2, 2)); ringCenterVector.normalize(); logger.debug("placeFusedRing->: ringCenterVector.length()" + ringCenterVector.length()); ringCenterVector.scale(newRingPerpendicular); ringCenter.add(ringCenterVector); IAtom bondAtom1 = sharedAtoms.getAtom(0); IAtom bondAtom2 = sharedAtoms.getAtom(1); Vector2d bondAtom1Vector = new Vector2d(bondAtom1.getPoint2d()); Vector2d bondAtom2Vector = new Vector2d(bondAtom2.getPoint2d()); Vector2d originRingCenterVector = new Vector2d(ringCenter); bondAtom1Vector.sub(originRingCenterVector); bondAtom2Vector.sub(originRingCenterVector); double occupiedAngle = bondAtom1Vector.angle(bondAtom2Vector); double remainingAngle = (2 * Math.PI) - occupiedAngle; double addAngle = remainingAngle / (ring.getRingSize() - 1); logger.debug("placeFusedRing->occupiedAngle: " + Math.toDegrees(occupiedAngle)); logger.debug("placeFusedRing->remainingAngle: " + Math.toDegrees(remainingAngle)); logger.debug("placeFusedRing->addAngle: " + Math.toDegrees(addAngle)); IAtom startAtom; double centerX = ringCenter.x; double centerY = ringCenter.y; double xDiff = bondAtom1.getPoint2d().x - bondAtom2.getPoint2d().x; double yDiff = bondAtom1.getPoint2d().y - bondAtom2.getPoint2d().y; double startAngle; ; int direction = 1; // if bond is vertical if (xDiff == 0) { logger.debug("placeFusedRing->Bond is vertical"); // starts with the lower Atom if (bondAtom1.getPoint2d().y > bondAtom2.getPoint2d().y) { startAtom = bondAtom1; } else { startAtom = bondAtom2; } // changes the drawing direction if (centerX < bondAtom1.getPoint2d().x) { direction = 1; } else { direction = -1; } } // if bond is not vertical else { // starts with the left Atom if (bondAtom1.getPoint2d().x > bondAtom2.getPoint2d().x) { startAtom = bondAtom1; } else { startAtom = bondAtom2; } // changes the drawing direction if (centerY - bondAtom1.getPoint2d().y > (centerX - bondAtom1.getPoint2d().x) * yDiff / xDiff) { direction = 1; } else { direction = -1; } } startAngle = GeometryTools.getAngle( startAtom.getPoint2d().x - ringCenter.x, startAtom.getPoint2d().y - ringCenter.y); IAtom currentAtom = startAtom; // determine first bond in Ring // int k = 0; // for (k = 0; k < ring.getElectronContainerCount(); k++) { // if (ring.getElectronContainer(k) instanceof IBond) break; // } IBond currentBond = sharedAtoms.getBond(0); Vector atomsToDraw = new Vector(); for (int i = 0; i < ring.getBondCount() - 2; i++) { currentBond = ring.getNextBond(currentBond, currentAtom); currentAtom = currentBond.getConnectedAtom(currentAtom); atomsToDraw.addElement(currentAtom); } addAngle = addAngle * direction; try { logger.debug("placeFusedRing->startAngle: " + Math.toDegrees(startAngle)); logger.debug("placeFusedRing->addAngle: " + Math.toDegrees(addAngle)); logger.debug("placeFusedRing->startAtom is: " + (molecule.getAtomNumber(startAtom) + 1)); logger.debug("AtomsToDraw: " + atomPlacer.listNumbers(molecule, atomsToDraw)); } catch (Exception exc) { logger.debug("Caught an exception while logging in RingPlacer"); } atomPlacer.populatePolygonCorners(atomsToDraw, ringCenter, startAngle, addAngle, radius); }
/** * @param atom1 * @param atom2 */ public synchronized void put(IAtom atom1, IAtom atom2) { mapping.put(atom1, atom2); mappingIndex.put(query.getAtomNumber(atom1), target.getAtomNumber(atom2)); }
/** * This makes atom map1 of matching atoms out of atom map1 of matching bonds as produced by the * get(Subgraph|Ismorphism)Map methods. Added by Asad since CDK one doesn't pick up the correct * changes * * @param list The list produced by the getMap method. * @param sourceGraph first molecule. Must not be an IQueryAtomContainer. * @param targetGraph second molecule. May be an IQueryAtomContainer. * @return The mapping found projected on sourceGraph. This is atom List of CDKRMap objects * containing Ids of matching atoms. */ private synchronized List<List<CDKRMap>> makeAtomsMapOfBondsMapSingleBond( List<CDKRMap> list, IAtomContainer sourceGraph, IAtomContainer targetGraph) { if (list == null) { return null; } Map<IBond, IBond> bondMap = new HashMap<IBond, IBond>(list.size()); for (CDKRMap solBondMap : list) { int id1 = solBondMap.getId1(); int id2 = solBondMap.getId2(); IBond qBond = sourceGraph.getBond(id1); IBond tBond = targetGraph.getBond(id2); bondMap.put(qBond, tBond); } List<CDKRMap> result1 = new ArrayList<CDKRMap>(); List<CDKRMap> result2 = new ArrayList<CDKRMap>(); for (IBond qbond : sourceGraph.bonds()) { if (bondMap.containsKey(qbond)) { IBond tbond = bondMap.get(qbond); CDKRMap map00 = null; CDKRMap map01 = null; CDKRMap map10 = null; CDKRMap map11 = null; if ((qbond.getAtom(0).getSymbol().equals(tbond.getAtom(0).getSymbol())) && (qbond.getAtom(1).getSymbol().equals(tbond.getAtom(1).getSymbol()))) { map00 = new CDKRMap( sourceGraph.getAtomNumber(qbond.getAtom(0)), targetGraph.getAtomNumber(tbond.getAtom(0))); map11 = new CDKRMap( sourceGraph.getAtomNumber(qbond.getAtom(1)), targetGraph.getAtomNumber(tbond.getAtom(1))); if (!result1.contains(map00)) { result1.add(map00); } if (!result1.contains(map11)) { result1.add(map11); } } if ((qbond.getAtom(0).getSymbol().equals(tbond.getAtom(1).getSymbol())) && (qbond.getAtom(1).getSymbol().equals(tbond.getAtom(0).getSymbol()))) { map01 = new CDKRMap( sourceGraph.getAtomNumber(qbond.getAtom(0)), targetGraph.getAtomNumber(tbond.getAtom(1))); map10 = new CDKRMap( sourceGraph.getAtomNumber(qbond.getAtom(1)), targetGraph.getAtomNumber(tbond.getAtom(0))); if (!result2.contains(map01)) { result2.add(map01); } if (!result2.contains(map10)) { result2.add(map10); } } } } List<List<CDKRMap>> result = new ArrayList<List<CDKRMap>>(); if (result1.size() == result2.size()) { result.add(result1); result.add(result2); } else if (result1.size() > result2.size()) { result.add(result1); } else { result.add(result2); } return result; }
@TestMethod(value = "testCalculate_IAtomContainer") public DescriptorValue calculate( IAtom atom, IAtomContainer atomContainer, IRingSet precalculatedringset) { IAtomContainer varAtomContainer; try { varAtomContainer = (IAtomContainer) atomContainer.clone(); } catch (CloneNotSupportedException e) { return getDummyDescriptorValue(e); } int atomPosition = atomContainer.getAtomNumber(atom); IAtom clonedAtom = varAtomContainer.getAtom(atomPosition); DoubleArrayResult rdfProtonCalculatedValues = new DoubleArrayResult(gsr_desc_length); if (!atom.getSymbol().equals("H")) { return getDummyDescriptorValue(new CDKException("Invalid atom specified")); } ///////////////////////// FIRST SECTION OF MAIN METHOD: DEFINITION OF MAIN VARIABLES ///////////////////////// AND AROMATICITY AND PI-SYSTEM AND RINGS DETECTION Molecule mol = new Molecule(varAtomContainer); if (varAtomContainer != acold) { acold = varAtomContainer; // DETECTION OF pi SYSTEMS varAtomContainerSet = ConjugatedPiSystemsDetector.detect(mol); if (precalculatedringset == null) try { varRingSet = (new AllRingsFinder()).findAllRings(varAtomContainer); } catch (CDKException e) { return getDummyDescriptorValue(e); } else varRingSet = precalculatedringset; try { GasteigerMarsiliPartialCharges peoe = new GasteigerMarsiliPartialCharges(); peoe.assignGasteigerMarsiliSigmaPartialCharges(mol, true); } catch (Exception ex1) { return getDummyDescriptorValue(ex1); } } if (checkAromaticity) { try { AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(varAtomContainer); CDKHueckelAromaticityDetector.detectAromaticity(varAtomContainer); } catch (CDKException e) { return getDummyDescriptorValue(e); } } IRingSet rsAtom; Ring ring; IRingSet ringsWithThisBond; // SET ISINRING FLAGS FOR BONDS Iterator<IBond> bondsInContainer = varAtomContainer.bonds().iterator(); while (bondsInContainer.hasNext()) { IBond bond = bondsInContainer.next(); ringsWithThisBond = varRingSet.getRings(bond); if (ringsWithThisBond.getAtomContainerCount() > 0) { bond.setFlag(CDKConstants.ISINRING, true); } } // SET ISINRING FLAGS FOR ATOMS IRingSet ringsWithThisAtom; for (int w = 0; w < varAtomContainer.getAtomCount(); w++) { ringsWithThisAtom = varRingSet.getRings(varAtomContainer.getAtom(w)); if (ringsWithThisAtom.getAtomContainerCount() > 0) { varAtomContainer.getAtom(w).setFlag(CDKConstants.ISINRING, true); } } IAtomContainer detected = varAtomContainerSet.getAtomContainer(0); // neighboors[0] is the atom joined to the target proton: List<IAtom> neighboors = mol.getConnectedAtomsList(clonedAtom); IAtom neighbour0 = neighboors.get(0); // 2', 3', 4', 5', 6', and 7' atoms up to the target are detected: List<IAtom> atomsInSecondSphere = mol.getConnectedAtomsList(neighbour0); List<IAtom> atomsInThirdSphere; List<IAtom> atomsInFourthSphere; List<IAtom> atomsInFifthSphere; List<IAtom> atomsInSixthSphere; List<IAtom> atomsInSeventhSphere; // SOME LISTS ARE CREATED FOR STORING OF INTERESTING ATOMS AND BONDS DURING DETECTION ArrayList<Integer> singles = new ArrayList<Integer>(); // list of any bond not rotatable ArrayList<Integer> doubles = new ArrayList<Integer>(); // list with only double bonds ArrayList<Integer> atoms = new ArrayList<Integer>(); // list with all the atoms in spheres // atoms.add( Integer.valueOf( mol.getAtomNumber(neighboors[0]) ) ); ArrayList<Integer> bondsInCycloex = new ArrayList<Integer>(); // list for bonds in cycloexane-like rings // 2', 3', 4', 5', 6', and 7' bonds up to the target are detected: IBond secondBond; // (remember that first bond is proton bond) IBond thirdBond; // IBond fourthBond; // IBond fifthBond; // IBond sixthBond; // IBond seventhBond; // // definition of some variables used in the main FOR loop for detection of interesting atoms and // bonds: boolean theBondIsInA6MemberedRing; // this is like a flag for bonds which are in cycloexane-like // rings (rings with more than 4 at.) IBond.Order bondOrder; int bondNumber; int sphere; // THIS MAIN FOR LOOP DETECT RIGID BONDS IN 7 SPHERES: for (IAtom curAtomSecond : atomsInSecondSphere) { secondBond = mol.getBond(neighbour0, curAtomSecond); if (mol.getAtomNumber(curAtomSecond) != atomPosition && getIfBondIsNotRotatable(mol, secondBond, detected)) { sphere = 2; bondOrder = secondBond.getOrder(); bondNumber = mol.getBondNumber(secondBond); theBondIsInA6MemberedRing = false; checkAndStore( bondNumber, bondOrder, singles, doubles, bondsInCycloex, mol.getAtomNumber(curAtomSecond), atoms, sphere, theBondIsInA6MemberedRing); atomsInThirdSphere = mol.getConnectedAtomsList(curAtomSecond); if (atomsInThirdSphere.size() > 0) { for (IAtom curAtomThird : atomsInThirdSphere) { thirdBond = mol.getBond(curAtomThird, curAtomSecond); // IF THE ATOMS IS IN THE THIRD SPHERE AND IN A CYCLOEXANE-LIKE RING, IT IS STORED IN // THE PROPER LIST: if (mol.getAtomNumber(curAtomThird) != atomPosition && getIfBondIsNotRotatable(mol, thirdBond, detected)) { sphere = 3; bondOrder = thirdBond.getOrder(); bondNumber = mol.getBondNumber(thirdBond); theBondIsInA6MemberedRing = false; // if the bond is in a cyclohexane-like ring (a ring with 5 or more atoms, not // aromatic) // the boolean "theBondIsInA6MemberedRing" is set to true if (!thirdBond.getFlag(CDKConstants.ISAROMATIC)) { if (!curAtomThird.equals(neighbour0)) { rsAtom = varRingSet.getRings(thirdBond); for (int f = 0; f < rsAtom.getAtomContainerCount(); f++) { ring = (Ring) rsAtom.getAtomContainer(f); if (ring.getRingSize() > 4 && ring.contains(thirdBond)) { theBondIsInA6MemberedRing = true; } } } } checkAndStore( bondNumber, bondOrder, singles, doubles, bondsInCycloex, mol.getAtomNumber(curAtomThird), atoms, sphere, theBondIsInA6MemberedRing); theBondIsInA6MemberedRing = false; atomsInFourthSphere = mol.getConnectedAtomsList(curAtomThird); if (atomsInFourthSphere.size() > 0) { for (IAtom curAtomFourth : atomsInFourthSphere) { fourthBond = mol.getBond(curAtomThird, curAtomFourth); if (mol.getAtomNumber(curAtomFourth) != atomPosition && getIfBondIsNotRotatable(mol, fourthBond, detected)) { sphere = 4; bondOrder = fourthBond.getOrder(); bondNumber = mol.getBondNumber(fourthBond); theBondIsInA6MemberedRing = false; checkAndStore( bondNumber, bondOrder, singles, doubles, bondsInCycloex, mol.getAtomNumber(curAtomFourth), atoms, sphere, theBondIsInA6MemberedRing); atomsInFifthSphere = mol.getConnectedAtomsList(curAtomFourth); if (atomsInFifthSphere.size() > 0) { for (IAtom curAtomFifth : atomsInFifthSphere) { fifthBond = mol.getBond(curAtomFifth, curAtomFourth); if (mol.getAtomNumber(curAtomFifth) != atomPosition && getIfBondIsNotRotatable(mol, fifthBond, detected)) { sphere = 5; bondOrder = fifthBond.getOrder(); bondNumber = mol.getBondNumber(fifthBond); theBondIsInA6MemberedRing = false; checkAndStore( bondNumber, bondOrder, singles, doubles, bondsInCycloex, mol.getAtomNumber(curAtomFifth), atoms, sphere, theBondIsInA6MemberedRing); atomsInSixthSphere = mol.getConnectedAtomsList(curAtomFifth); if (atomsInSixthSphere.size() > 0) { for (IAtom curAtomSixth : atomsInSixthSphere) { sixthBond = mol.getBond(curAtomFifth, curAtomSixth); if (mol.getAtomNumber(curAtomSixth) != atomPosition && getIfBondIsNotRotatable(mol, sixthBond, detected)) { sphere = 6; bondOrder = sixthBond.getOrder(); bondNumber = mol.getBondNumber(sixthBond); theBondIsInA6MemberedRing = false; checkAndStore( bondNumber, bondOrder, singles, doubles, bondsInCycloex, mol.getAtomNumber(curAtomSixth), atoms, sphere, theBondIsInA6MemberedRing); atomsInSeventhSphere = mol.getConnectedAtomsList(curAtomSixth); if (atomsInSeventhSphere.size() > 0) { for (IAtom curAtomSeventh : atomsInSeventhSphere) { seventhBond = mol.getBond(curAtomSeventh, curAtomSixth); if (mol.getAtomNumber(curAtomSeventh) != atomPosition && getIfBondIsNotRotatable(mol, seventhBond, detected)) { sphere = 7; bondOrder = seventhBond.getOrder(); bondNumber = mol.getBondNumber(seventhBond); theBondIsInA6MemberedRing = false; checkAndStore( bondNumber, bondOrder, singles, doubles, bondsInCycloex, mol.getAtomNumber(curAtomSeventh), atoms, sphere, theBondIsInA6MemberedRing); } } } } } } } } } } } } } } } } } // Variables double[] values; // for storage of results of other methods double distance; double sum; double smooth = -20; double partial; int position; double limitInf; double limitSup; double step; //////////////////////// THE FOUTH DESCRIPTOR IS gS(r), WHICH TAKES INTO ACCOUNT SINGLE BONDS IN // RIGID SYSTEMS Vector3d a_a = new Vector3d(); Vector3d a_b = new Vector3d(); Vector3d b_a = new Vector3d(); Vector3d b_b = new Vector3d(); Point3d middlePoint = new Point3d(); double angle = 0; if (singles.size() > 0) { double dist0; double dist1; IAtom singleBondAtom0; IAtom singleBondAtom1; distance = 0; position = 0; IBond theSingleBond = null; limitInf = 0; limitSup = Math.PI / 2; step = (limitSup - limitInf) / 7; smooth = -1.15; int counter = 0; for (double ghs = 0; ghs < limitSup; ghs = ghs + step) { sum = 0; for (int sing = 0; sing < singles.size(); sing++) { angle = 0; partial = 0; Integer thisSingleBond = singles.get(sing); position = thisSingleBond; theSingleBond = mol.getBond(position); middlePoint = theSingleBond.get3DCenter(); singleBondAtom0 = theSingleBond.getAtom(0); singleBondAtom1 = theSingleBond.getAtom(1); dist0 = calculateDistanceBetweenTwoAtoms(singleBondAtom0, atom); dist1 = calculateDistanceBetweenTwoAtoms(singleBondAtom1, atom); a_a.set(middlePoint.x, middlePoint.y, middlePoint.z); if (dist1 > dist0) a_b.set( singleBondAtom0.getPoint3d().x, singleBondAtom0.getPoint3d().y, singleBondAtom0.getPoint3d().z); else a_b.set( singleBondAtom1.getPoint3d().x, singleBondAtom1.getPoint3d().y, singleBondAtom1.getPoint3d().z); b_a.set(middlePoint.x, middlePoint.y, middlePoint.z); b_b.set(atom.getPoint3d().x, atom.getPoint3d().y, atom.getPoint3d().z); values = calculateDistanceBetweenAtomAndBond(atom, theSingleBond); angle = calculateAngleBetweenTwoLines(a_a, a_b, b_a, b_b); // System.out.println("ANGLe: "+angle+ " "+ mol.getAtomNumber(atomsInSingleBond[0]) +" " // +mol.getAtomNumber(atomsInSingleBond[1])); partial = (1 / (Math.pow(values[0], 2))) * Math.exp(smooth * (Math.pow((ghs - angle), 2))); sum += partial; } // gSr_function.add(new Double(sum)); rdfProtonCalculatedValues.add(sum); logger.debug("RDF gSr prob.: " + sum + " at distance " + ghs); counter++; } } else { return getDummyDescriptorValue(new CDKException("Some error occurred. Please report")); } return new DescriptorValue( getSpecification(), getParameterNames(), getParameters(), rdfProtonCalculatedValues, 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; }