toxtree 0.0.1

data/Toxtree-v2.6.13/src/toxTree/tree/rules/RuleRingSubstituents.java

@@ -0,0 +1,156 @@
+/*
+Copyright Ideaconsult Ltd. (C) 2005-2007 
+
+Contact: nina@acad.bg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+All we ask is that proper credit is given for our work, which includes
+- but is not limited to - adding the above copyright notice to the beginning
+of your source code files, and to any copyright notice that you may distribute
+with programs based on this work.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+*/
+package toxTree.tree.rules;
+
+import org.openscience.cdk.CDKConstants;
+import org.openscience.cdk.graph.ConnectivityChecker;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IMolecule;
+import org.openscience.cdk.interfaces.IMoleculeSet;
+import org.openscience.cdk.interfaces.IRing;
+import org.openscience.cdk.interfaces.IRingSet;
+
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.query.FunctionalGroups;
+import toxTree.query.MolAnalyser;
+
+/**
+ * A rule to analyze ring substituents
+ * @author Nina Jeliazkova
+ * <b>Modified</b> 2005-8-17
+ */
+public abstract class RuleRingSubstituents extends RuleRings {
+	public static String ERR_PRECONDITION_FAILED = "Forbidden ring substituent found (precondition failed)";
+	public static String CONDITION_FAILED = "Forbidden substructure found in a ring substituent";
+	public static String CYCLIC_SUBSTITUENT = "Ring substituent bearing another ring!";
+	public static String LONGCHAIN_SUBSTITUENT = "Ring substituent with > 5 carbon atoms!\t - ";
+	
+
+	protected boolean[] flags = null;
+	protected boolean analyzeOnlyRingsWithFlagSet = false;
+	/**
+	 * Comment for <code>serialVersionUID</code>
+	 */
+	private static final long serialVersionUID = 8095271692686086087L;
+
+	/**
+	 * 
+	 */
+	public RuleRingSubstituents() {
+		super();
+
+	    flags = new boolean[CDKConstants.MAX_FLAG_INDEX+1];
+	    clearFlags();
+	}
+
+	protected boolean analyze(IRing r) {
+		
+		if (analyzeOnlyRingsWithFlagSet) {
+			if (flags[flags.length-1]) {
+				Object o = r.getProperty(MolAnalyser.HETEROCYCLIC);
+				if (o==null) return false;
+				if (((Boolean) o).booleanValue()) return true;
+			}
+			boolean[] ringFlags = r.getFlags();
+			for (int i=0; i<(flags.length-1); i++)
+				if (i>=ringFlags.length) break;
+				else if (ringFlags[i] && flags[i]) return true;
+							
+			return false;
+
+		} else return true;
+	}	
+
+	/**
+	 *returns true if the substituent is allowed and false if it is forbidden 
+	 *to be implemented by the inheriting class
+	 */
+	public abstract boolean substituentIsAllowed(IAtomContainer  a, int[] place) throws DecisionMethodException;
+	
+	public void clearFlags() {
+		for (int i=0; i<flags.length; i++) flags[i] = false;
+	}
+	public void setAnalyzeHeterocyclic(boolean flag) {
+		flags[CDKConstants.MAX_FLAG_INDEX] = flag;
+	}
+	public void setAnalyzeAromatic(boolean flag) {
+		flags[CDKConstants.ISAROMATIC] = flag;
+	}		
+	/**
+	 * @return Returns the analyzeOnlyRingsWithFlagSet.
+	 */
+	public boolean analyzeOnlyRingsWithFlagSet() {
+		return analyzeOnlyRingsWithFlagSet;
+	}
+	/**
+	 * @param analyzeOnlyRingsWithFlagSet The analyzeOnlyRingsWithFlagSet to set.
+	 */
+	public void setAnalyzeOnlyRingsWithFlagSet(
+			boolean analyzeOnlyRingsWithFlagSet) {
+		this.analyzeOnlyRingsWithFlagSet = analyzeOnlyRingsWithFlagSet;
+	}
+	public String allowedSubstituents() {
+		return "Allowed substituents:\t" + ids.toString();
+	}
+	/**
+	 * {@link toxTree.core.IDecisionRule#verifyRule(IAtomContainer)}
+	 */
+	public boolean verifyRule(IAtomContainer mol) throws DecisionMethodException {
+		return verifyRule(mol,null);
+	};
+	public boolean verifyRule(IAtomContainer  mol, IAtomContainer selected) throws DecisionMethodException {
+		logger.fine(toString());
+		IRingSet rs = hasRingsToProcess(mol);
+		if (rs == null) return false;
+		
+	    IRing r =null;
+	    for (int i=0; i < rs.getAtomContainerCount(); i++) {
+	        r = (IRing) rs.getAtomContainer(i);
+	        if (!analyze(r)) continue;
+	        logger.finer("Ring\t"+(i+1));
+	        
+	        //new atomcontainer with ring atoms/bonds deleted
+	        IAtomContainer mc = FunctionalGroups.cloneDiscardRingAtomAndBonds(mol,r);	        
+			logger.finer("\tmol atoms\t"+mc.getAtomCount());
+		    
+			IMoleculeSet  s = ConnectivityChecker.partitionIntoMolecules(mc);
+			//logger.debug("partitions\t",s.getMoleculeCount());
+			for (int k = 0; k < s.getMoleculeCount(); k++) {
+				IMolecule m = s.getMolecule(k);
+			    if (m!=null) {
+				    if ((m.getAtomCount() == 1) && (m.getAtom(0).getSymbol().equals("H"))) continue;
+				    logger.finer("Ring substituent\t"+(k+1));
+				    if (!substituentIsAllowed(m,null)) {
+				    	logger.finer(ERR_PRECONDITION_FAILED);
+				    	return false;
+				    }
+			    }
+			}	        
+	    }
+	    return true;
+		
+	}
+	
+}

data/Toxtree-v2.6.13/src/toxTree/tree/rules/RuleRings.java

@@ -0,0 +1,46 @@
+/*
+ Copyright Ideaconsult Ltd. (C) 2005-2007  
+ Contact: nina@acad.bg
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+ */
+
+package toxTree.tree.rules;
+
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IRingSet;
+
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.query.MolFlags;
+
+public abstract class RuleRings extends RuleSubstructures {
+
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 5753973449345355629L;
+
+    public RuleRings() {
+        super();
+    }
+
+    protected IRingSet hasRingsToProcess(IAtomContainer  mol) throws DecisionMethodException {
+        MolFlags mf = (MolFlags) mol.getProperty(MolFlags.MOLFLAGS);
+        if (mf == null) throw new DecisionMethodException(ERR_STRUCTURENOTPREPROCESSED);
+        return mf.getRingset();
+    }
+
+}

data/Toxtree-v2.6.13/src/toxTree/tree/rules/RuleStructuresList.java

@@ -0,0 +1,211 @@
+/*
+Copyright Ideaconsult Ltd. (C) 2005-2007 
+
+Contact: nina@acad.bg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+All we ask is that proper credit is given for our work, which includes
+- but is not limited to - adding the above copyright notice to the beginning
+of your source code files, and to any copyright notice that you may distribute
+with programs based on this work.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+ */
+package toxTree.tree.rules;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.util.logging.Level;
+
+import net.idea.modbcum.i.exceptions.AmbitException;
+import net.idea.modbcum.i.processors.IProcessor;
+
+import org.openscience.cdk.exception.CDKException;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.renderer.selection.IChemObjectSelection;
+import org.openscience.cdk.renderer.selection.SingleSelection;
+
+import toxTree.core.Introspection;
+import toxTree.exceptions.DRuleNotImplemented;
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.io.Tools;
+import toxTree.tree.AbstractRule;
+
+/**
+ * A rule, which returns true if the query is isomorphic to one of the
+ * structures read from a preconfigured file of a type SDF, SMI, CSV
+ * 
+ * @author Nina Jeliazkova <b>Modified</b> 2005-9-6
+ */
+public class RuleStructuresList extends AbstractRule {
+
+	protected transient ILookupFile lookupFile;
+	protected String filename = null;
+	/**
+	 * Comment for <code>serialVersionUID</code>
+	 */
+	private static final long serialVersionUID = 1445819316236082148L;
+
+	/**
+	 * 
+	 */
+	public RuleStructuresList() {
+		this(new File(Introspection.getToxTreeRoot() + "bodymol.sdf"));
+
+	}
+
+	public RuleStructuresList(String resource) {
+		this(Tools.getFileFromResourceSilent(resource));
+	}
+
+	public RuleStructuresList(File file) {
+		super();
+
+		try {
+			setFile(file);
+
+		} catch (Exception x) {
+			try {
+				setFile(Tools.getFileFromResource(file.getName()));
+			} catch (Exception xx) {
+				lookupFile = null;
+			}
+			logger.log(Level.SEVERE, x.getMessage(), x);
+		}
+		setExplanation("Returns true if the query is isomorphic to one of the structures loaded from a preconfigured file of a type SDF, SMI, CSV ");
+		setTitle("Exact search");
+
+	}
+
+	/**
+	 * {@link toxTree.core.IDecisionRule#verifyRule(IAtomContainer)}
+	 */
+	public boolean verifyRule(IAtomContainer mol)
+			throws DecisionMethodException {
+		if (lookupFile == null)
+			throw new DRuleNotImplemented();
+		return lookupFile.find(mol);
+
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see toxTree.tree.AbstractRule#isImplemented()
+	 */
+	@Override
+	public boolean isImplemented() {
+		return lookupFile.isEnabled();
+	}
+
+	/**
+	 * @return Returns the file.
+	 */
+	public synchronized File getFile() {
+		return lookupFile.getFile();
+	}
+
+	/**
+	 * @param file
+	 *            The file to set.
+	 */
+
+	public synchronized void setFile(File file) throws CDKException,
+			IOException {
+		lookupFile = new LookupFile(file);
+		setFilename(file.getAbsolutePath());
+
+		logger.fine("Will be using file\t" + file.getAbsoluteFile());
+
+	}
+
+	/**
+	 * public synchronized boolean isUsingCache() { return
+	 * lookupFile.isUseCache(); } public synchronized void setUsingCache(boolean
+	 * useCache) { lookupFile.setUseCache(useCache); } /*
+	 * 
+	 * @Override public IDecisionRuleEditor getEditor() { return new
+	 *           RuleStructuresPanel(this); }
+	 */
+	private void readObject(ObjectInputStream in) throws IOException,
+			ClassNotFoundException {
+		in.defaultReadObject();
+		try {
+			lookupFile = new LookupFile(getFilename());
+		} catch (Exception x) {
+			logger.log(Level.SEVERE, x.getMessage(), x);
+			lookupFile = null;
+		}
+	}
+
+	public synchronized String getFilename() {
+		return filename;
+	}
+
+	public synchronized void setFilename(String filename) {
+		this.filename = filename;
+	}
+
+	public boolean verifyRule(
+			org.openscience.cdk.interfaces.IAtomContainer mol,
+			IAtomContainer selected) throws DecisionMethodException {
+		boolean ok = verifyRule(mol);
+		if (ok && (selected != null))
+			selected.add(mol);
+		return ok;
+	}
+
+	public IProcessor<IAtomContainer, IChemObjectSelection> getSelector() {
+		return new IProcessor<IAtomContainer, IChemObjectSelection>() {
+			/**
+		     * 
+		     */
+		    private static final long serialVersionUID = 1941242188425144120L;
+
+			public IChemObjectSelection process(IAtomContainer mol)
+					throws AmbitException {
+				// try {
+				// IAtomContainer selected =
+				// SilentChemObjectBuilder.getInstance().newAtomContainer();
+				// verifyRule(mol, selected);
+				return new SingleSelection<IAtomContainer>(mol);
+				// } catch (DecisionMethodException x) {
+				// throw new AmbitException(x);
+				// }
+			}
+
+			public boolean isEnabled() {
+				return true;
+			}
+
+			public long getID() {
+				return 0;
+			}
+
+			public void setEnabled(boolean arg0) {
+			}
+
+			@Override
+			public void open() throws Exception {
+			}
+
+			@Override
+			public void close() throws Exception {
+			}
+
+		};
+	}
+
+}

data/Toxtree-v2.6.13/src/toxTree/tree/rules/RuleSubstructures.java

@@ -0,0 +1,191 @@
+/*
+Copyright Ideaconsult Ltd. (C) 2005-2007 
+
+Contact: nina@acad.bg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+All we ask is that proper credit is given for our work, which includes
+- but is not limited to - adding the above copyright notice to the beginning
+of your source code files, and to any copyright notice that you may distribute
+with programs based on this work.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+*/
+package toxTree.tree.rules;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.openscience.cdk.interfaces.IAtom;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IBond;
+
+import toxTree.core.IRuleSubstructures;
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.query.FunctionalGroups;
+import toxTree.query.MolAnalyser;
+import toxTree.query.QueryAtomContainers;
+import toxTree.tree.AbstractRuleHilightHits;
+
+/**
+ * An abstract class to implement substructure rules
+ * @author Nina Jeliazkova
+ * <b>Modified</b> 2005-8-14
+ */
+public abstract class RuleSubstructures extends AbstractRuleHilightHits implements IRuleSubstructures {
+	public static transient String MSG_HASGROUP = "Has group\t";
+	/**
+	 * Comment for <code>serialVersionUID</code>
+	 */
+	private static final long serialVersionUID = -2500957952948758410L;
+	protected QueryAtomContainers query = null;
+	protected ArrayList ids = null;	
+	/**
+	 * 
+	 */
+	public RuleSubstructures() {
+		super();
+		query = new QueryAtomContainers();
+		ids = new ArrayList();
+	    ids.add(FunctionalGroups.C);	    
+	    ids.add(FunctionalGroups.CH);
+	    ids.add(FunctionalGroups.CH2);
+	    ids.add(FunctionalGroups.CH3);		
+	}
+
+	/* (non-Javadoc)
+	 * @see toxTree.tree.AbstractRule#isImplemented()
+	 */
+	@Override
+	public boolean isImplemented() {
+		return getSubstructuresCount()>0;
+	}
+	/**
+	 * The fragment will be added to the list of substructures to be searched for
+	 * @param fragment
+	/* (non-Javadoc)
+	 * @see toxTree.tree.rules.RuleSubstructures#addSubstructure(IAtomContainer)
+	 */
+	public void addSubstructure(IAtomContainer fragment) {
+		query.add(fragment);
+		ids.add(fragment.getID());
+		setChanged();
+		notifyObservers();
+	}
+
+
+	/* (non-Javadoc)
+	 * @see toxTree.tree.rules.RuleSubstructures#clearSubstructures()
+	 */
+	public void clearSubstructures() {
+		ids.clear();
+	    ids.add(FunctionalGroups.C);	    
+	    ids.add(FunctionalGroups.CH);
+	    ids.add(FunctionalGroups.CH2);
+	    ids.add(FunctionalGroups.CH3);		
+	    setChanged();
+	    notifyObservers();
+	}
+	public int getSubstructuresCount() {
+		return query.size();
+	}
+	public IAtomContainer getSubstructure(int index) {
+        if (index < query.getAtomContainerCount())
+            return (IAtomContainer) query.get(index);
+        else return null;
+	}
+	/* (non-Javadoc)
+	 * @see toxTree.core.IRuleSubstructures#setSubstructure(int, org.openscience.cdk.interfaces.AtomContainer)
+	 */
+	public void setSubstructure(int index, IAtomContainer atomContainer) {
+		query.set(index,atomContainer);
+		setChanged();
+		notifyObservers();
+
+	}
+	/* (non-Javadoc)
+	 * @see toxTree.tree.AbstractRule#equals(java.lang.Object)
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (!super.equals(obj)) return false;
+		if (obj instanceof RuleSubstructures) {
+			RuleSubstructures rule = (RuleSubstructures) obj;
+			if (query.size() != rule.query.size()) return false;
+			else return ids.containsAll(rule.ids);
+		} else return false;
+	}
+	
+	public IAtomContainer removeSubstructure(int index) {
+		IAtomContainer a = getSubstructure(index);
+		if (a != null) {
+			ids.remove(a.getID());
+			query.remove(a);
+		}
+		setChanged();
+		notifyObservers();
+		return a;
+	}
+	public List getSubstructures() {
+		return query;
+	}
+	/*
+	@Override
+	public IDecisionRuleEditor getEditor() {
+		return new SubstructureRulePanel(this);
+	}
+	*/
+
+	public QueryAtomContainers getQuery() {
+		return query;
+	}
+
+	public void setQuery(QueryAtomContainers query) {
+		this.query = query;
+	}
+
+	public ArrayList getIds() {
+		return ids;
+	}
+
+	public void setIds(ArrayList ids) {
+		this.ids = ids;
+	}	
+	
+	@Override
+	public boolean verifyRule(IAtomContainer mol, IAtomContainer selected)
+			throws DecisionMethodException {
+		logger.fine(toString());
+		try {
+			MolAnalyser.analyse(mol);
+			boolean ok = verifyRule(mol);
+			if (selected != null) {
+				for (IAtom atom: mol.atoms())
+					if (!"H".equals(atom.getSymbol()) && atom.getProperty(FunctionalGroups.ALLOCATED)!=null)
+						selected.addAtom(atom);
+				
+				for (IBond bond:mol.bonds()) 
+					if ((bond.getProperty(FunctionalGroups.ALLOCATED)!=null) &&
+						 !"H".equals(bond.getAtom(0).getSymbol()) &&
+						 !"H".equals(bond.getAtom(1).getSymbol())
+						 )
+						selected.addBond(bond);				
+			}	
+			
+			return ok;
+		} catch (Exception x) {
+			throw new DecisionMethodException(x);
+		}
+	}
+}