From: Christoph S. <ste...@us...> - 2002-05-31 21:25:39
|
Update of /cvsroot/cdk/cdk/org/openscience/cdk/fingerprint In directory usw-pr-cvs1:/tmp/cvs-serv4205 Modified Files: Fingerprinter.java Log Message: The Fingerprinter now checks for aromaticity before generating fingerprints. Several severe bugs were fixed. Index: Fingerprinter.java =================================================================== RCS file: /cvsroot/cdk/cdk/org/openscience/cdk/fingerprint/Fingerprinter.java,v retrieving revision 1.5 retrieving revision 1.6 diff -C2 -r1.5 -r1.6 *** Fingerprinter.java 6 Apr 2002 15:26:44 -0000 1.5 --- Fingerprinter.java 31 May 2002 21:25:37 -0000 1.6 *************** *** 31,34 **** --- 31,36 ---- import org.openscience.cdk.*; + import org.openscience.cdk.aromaticity.*; + import org.openscience.cdk.exception.*; import java.util.*; *************** *** 45,49 **** { static int defaultSize = 1024; ! static int searchDepth = 7; static Hashtable pathes; static boolean debug = false; --- 47,51 ---- { static int defaultSize = 1024; ! static int searchDepth = 6; static Hashtable pathes; static boolean debug = false; *************** *** 57,61 **** * @return The Fingerprint (A one-dimensional bit array) */ ! public static BitSet getFingerprint(AtomContainer ac) { return getFingerprint(ac, defaultSize); --- 59,63 ---- * @return The Fingerprint (A one-dimensional bit array) */ ! public static BitSet getFingerprint(AtomContainer ac) throws NoSuchAtomException { return getFingerprint(ac, defaultSize); *************** *** 70,76 **** * @return The Fingerprint (A one-dimensional bit array) */ ! public static BitSet getFingerprint(AtomContainer ac, int size) { String path = null; findPathes(ac); BitSet bs = new BitSet(size); --- 72,81 ---- * @return The Fingerprint (A one-dimensional bit array) */ ! public static BitSet getFingerprint(AtomContainer ac, int size) throws NoSuchAtomException { String path = null; + int position = -1; + boolean isAromatic = false; + isAromatic = HueckelAromaticityDetector.detectAromaticity(ac); findPathes(ac); BitSet bs = new BitSet(size); *************** *** 78,82 **** { path = (String) e.nextElement(); ! bs.set(new java.util.Random(path.hashCode()).nextInt(defaultSize)); } return bs; --- 83,89 ---- { path = (String) e.nextElement(); ! position = new java.util.Random(path.hashCode()).nextInt(defaultSize); ! if (debug) System.out.println("Setting bit " + position + " for " + path); ! bs.set(position); } return bs; *************** *** 116,124 **** for (int f = 0; f < ac.getAtomCount(); f++) { ! for (int g = 0; g < ac.getAtomCount(); g++) ! { ! ac.getAtomAt(g).flags[VISITED] = false; ! } ! depthFirstSearch(ac, ac.getAtomAt(f), "", 0); } } --- 123,129 ---- for (int f = 0; f < ac.getAtomCount(); f++) { ! checkAndStore(ac.getAtomAt(f).getSymbol()); ! if (debug) System.out.println("Starting at atom " + f + " with symbol " + ac.getAtomAt(f).getSymbol()); ! depthFirstSearch(ac, ac.getAtomAt(f), ac.getAtomAt(f).getSymbol(), 0); } } *************** *** 137,183 **** Bond[] bonds = ac.getConnectedBonds(root); Atom nextAtom = null; ! root.flags[VISITED] = true; currentDepth++; - String newPath = new String(currentPath); - String reversePath = null; - StringBuffer strBuff = null; for (int f = 0; f < bonds.length; f++) { ! nextAtom = bonds[f].getConnectedAtom(root); ! if (!nextAtom.flags[VISITED]) { ! newPath += nextAtom.getSymbol(); ! reversePath = new StringBuffer(newPath).reverse().toString(); ! if (!pathes.containsKey(newPath) && !pathes.containsKey(reversePath)) { ! pathes.put(newPath, newPath); ! if (debug) ! { ! debugCounter++; ! if (debug) System.out.println("Path no. " + debugCounter + ": " + newPath + ", Hash: " + newPath.hashCode()); ! } } ! if (currentDepth == searchDepth) { ! return; } ! if (bonds[f].getOrder() == 1) { newPath += "-"; } ! if (bonds[f].getOrder() == 1.5) ! { ! newPath += ":"; ! } ! if (bonds[f].getOrder() == 2) { newPath += "="; } ! if (bonds[f].getOrder() == 3) { newPath += "#"; } ! if (currentDepth < searchDepth - 1) { depthFirstSearch(ac, nextAtom, newPath, currentDepth); --- 142,187 ---- Bond[] bonds = ac.getConnectedBonds(root); Atom nextAtom = null; ! String newPath = null; ! currentDepth++; for (int f = 0; f < bonds.length; f++) { ! if (currentDepth == 1) { ! for (int g = 0; g < ac.getAtomCount(); g++) { ! ac.getAtomAt(g).flags[VISITED] = false; } ! root.flags[VISITED] = true; ! } ! nextAtom = bonds[f].getConnectedAtom(root); ! if (!nextAtom.flags[VISITED]) ! { ! newPath = new String(currentPath); ! if (bonds[f].flags[Bond.ISAROMATIC]) { ! newPath += ":"; } ! else if (bonds[f].getOrder() == 1) { newPath += "-"; } ! else if (bonds[f].getOrder() == 2) { newPath += "="; } ! else if (bonds[f].getOrder() == 3) { newPath += "#"; } ! newPath += nextAtom.getSymbol(); ! nextAtom.flags[VISITED] = true; ! checkAndStore(newPath); ! if (currentDepth == searchDepth) ! { ! return; ! } ! if (currentDepth < searchDepth) { depthFirstSearch(ac, nextAtom, newPath, currentDepth); *************** *** 185,188 **** --- 189,219 ---- } } + } + + private static void checkAndStore(String newPath) + { + String storePath = new String(newPath); + String reversePath = new StringBuffer(storePath).reverse().toString(); + + if (reversePath.compareTo(newPath) < 0) + { + /* reversePath is smaller than newPath + so we keep reversePath */ + storePath = reversePath; + } + if (debug) System.out.println("Checking for existence of Path " + storePath); + /* At this point we need to check wether the + same path has already been found in reversed order. If so, we need to store the + lexicographically smaller path (This is an arbitrary choice) */ + if (!pathes.containsKey(storePath)) + { + pathes.put(storePath, storePath); + if (debug) + { + debugCounter++; + if (debug) System.out.println("Storing path no. " + debugCounter + ": " + storePath + ", Hash: " + storePath.hashCode()); + } + } + } } |