toxtree 0.0.1

data/Toxtree-v2.6.13/src/mutant/descriptors/whim_weights.txt

@@ -0,0 +1,39 @@
+Symbol	Mass	VdWVolume	Electronegativity	Polarizability
+H	1.01	6.71	2.59	0.67
+B	10.81	17.88	2.28	3.03
+C	12.01	22.45	2.75	1.76
+N	14.01	15.6	3.19	1.1
+O	16	11.49	3.65	0.8
+F	19	9.2	4	0.56
+Al	26.98	36.51	1.71	6.8
+Si	28.09	31.98	2.14	5.38
+P	30.97	26.52	2.52	3.63
+S	32.07	24.43	2.96	2.9
+Cl	35.45	22.45	3.48	2.18
+Cr	52	44.6	1.66	11.6
+Mn	54.94	43.4	2.2	9.4
+Fe	55.85	41.05	2.2	8.4
+Co	58.93	35.04	2.56	7.5
+Ni	58.69	17.16	1.94	6.8
+Cu	63.55	11.49	1.98	6.1
+Zn	65.39	11.25	2.23	7.1
+Ga	69.72	27.39	2.42	8.12
+Ge	72.61	28.73	2.62	6.07
+As	74.92	26.52	2.82	4.31
+Se	78.96	28.73	3.01	3.77
+Br	79.9	31.06	3.22	3.05
+Mo	95.94	33.51	1.15	12.8
+Ag	107.87	21.31	1.83	7.2
+Cd	112.41	16.52	1.98	7.2
+In	114.82	30.11	2.14	10.2
+Sn	118.71	45.83	2.3	7.7
+Sb	121.76	38.79	2.46	6.6
+Te	127.6	36.62	2.62	5.5
+I	126.9	38.79	2.78	5.35
+Gd	157.25	72.78	2	23.5
+Pt	195.08	22.45	2.28	6.5
+Au	196.97	19.16	2.54	5.8
+Hg	200.59	15.6	2.2	5.7
+Tl	204.38	31.54	2.25	7.6
+Pb	207.2	34.53	2.29	6.8
+Bi	208.98	38.79	2.34	7.4

data/Toxtree-v2.6.13/src/mutant/rules/MutantTreeResult.java

@@ -0,0 +1,348 @@
+/*
+Copyright (C) 2005-2006  
+
+Contact: nina@acad.bg
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public License
+as published by the Free Software Foundation; either version 2.1
+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 Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
+*/
+
+package mutant.rules;
+
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.logging.Level;
+
+import mutant.categories.CategoryCarcinogen;
+import mutant.categories.CategoryMutagenTA100;
+import mutant.categories.CategoryNoGenotoxicAlert;
+import mutant.categories.CategoryNoNongenotoxicAlert;
+import mutant.categories.CategoryNonMutagen;
+import mutant.categories.CategoryNotCarcinogen;
+import mutant.categories.CategoryPositiveAlertGenotoxic;
+import mutant.categories.CategoryPositiveAlertNongenotoxic;
+import net.idea.modbcum.i.exceptions.AmbitException;
+
+import org.openscience.cdk.interfaces.IAtomContainer;
+
+import toxTree.core.IDecisionCategories;
+import toxTree.core.IDecisionCategory;
+import toxTree.core.IDecisionRule;
+import toxTree.core.IDescriptorBased;
+import toxTree.data.CategoryFilter;
+import toxTree.exceptions.DMethodNotAssigned;
+import toxTree.exceptions.DecisionResultException;
+import toxTree.tree.DecisionNode;
+import toxTree.tree.ProgressStatus;
+import toxTree.tree.RuleResult;
+import toxTree.tree.TreeResult;
+import toxTree.tree.rules.IAlertCounter;
+import ambit2.base.data.ILiteratureEntry;
+import ambit2.base.data.ILiteratureEntry._type;
+import ambit2.base.data.Property;
+import ambit2.base.data.PropertyAnnotation;
+import ambit2.base.data.PropertyAnnotations;
+
+public class MutantTreeResult extends TreeResult {
+    protected static String SUFFIX = "SUFFIX";
+
+	protected String[] descriptors = {
+			"LSTM1","B5STM1","EHOMO","ELUMO","MR2","MR3","MR5","MR6","I(An)","I(NO2)","I(BiBr)","MR","LogP","Idist"
+			};
+    protected String[] qsar = {
+            "w_QSAR6","w_QSAR8","w_QSAR13"
+            };
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -1505391697761215610L;
+
+	public void assignResult(IAtomContainer mol) throws DecisionResultException {
+		if (mol == null) return;
+		IDecisionCategories c = decisionMethod.getCategories();
+		for (int i=0; i < c.size();i++) {
+			String result = Answers.toString(Answers.NO);
+			if (getAssignedCategories().indexOf(c.get(i))>-1)
+				result = Answers.toString(Answers.YES);
+			mol.setProperty(
+	        		c.get(i).toString(),
+	                result);
+		}
+
+        String paths = getClass().getName()+"#explanation";
+        if (getDecisionMethod().getRules().size() > 1) {
+	        mol.setProperty(
+	        		paths,
+	                explain(false).toString());
+	        Hashtable<String,String> b = getExplanation(mol);
+	        Enumeration<String> k = b.keys();
+	        while (k.hasMoreElements()) {
+	        	String key = k.nextElement();
+	        	mol.setProperty(key,b.get(key));
+	        }
+        } else
+        	mol.removeProperty(paths);
+        firePropertyChangeEvent(ProgressStatus._pRuleResult, null, status);        
+
+	}
+
+	@Override
+	public List<Property> getResultProperties() throws AmbitException {
+
+		if (getDecisionMethod() == null) throw new AmbitException("Unassigned method");
+		ILiteratureEntry le = getReference();
+		le.setType(_type.Algorithm);
+		List<Property> p = new ArrayList<Property>();
+		for (IDecisionCategory category : getDecisionMethod().getCategories()) {
+			Property property = new Property(category.toString(),le);
+			property.setLabel(le.getURL());
+			property.setClazz(String.class);
+			property.setOrder(p.size()+1);
+			property.setEnabled(true);
+			property.setNominal(true);
+			PropertyAnnotations pa = new PropertyAnnotations();
+			property.setAnnotations(pa);
+			PropertyAnnotation a = new PropertyAnnotation();
+			a.setType("^^"+category.getCategoryType().name());
+			a.setPredicate("acceptValue");
+			a.setObject(Answers.toString(Answers.YES));
+			pa.add(a);
+			a = new PropertyAnnotation();
+			a.setType("^^"+category.getNegativeCategoryType().name());
+			a.setPredicate("acceptValue");
+			a.setObject(Answers.toString(Answers.NO));
+			pa.add(a);
+			p.add(property);
+		}
+		
+		Property property = new Property(String.format("%s#explanation", getDecisionMethod().getTitle()),le); 
+		property.setLabel(le.getURL());
+		property.setClazz(String.class);
+		property.setOrder(p.size()+1);
+		property.setEnabled(true);
+		property.setNominal(false);
+		p.add(property);
+		
+		return p;
+	}
+	
+
+	
+	@Override
+	public String[] getResultPropertyNames() {
+		IDecisionCategories c = decisionMethod.getCategories();
+		String[] names = new String[c.size()];
+		for (int i=0; i < c.size();i++) 
+			names[i] = c.get(i).toString();
+		return names;
+	}
+	protected ArrayList<IAtomContainer> getAllAssignedMolecules() {
+        ArrayList<IAtomContainer> residues = new ArrayList<IAtomContainer>();
+        return residues;
+        /*
+        for (int i=0;i < ruleResults.size();i++) {
+            RuleResult r = ((RuleResult)ruleResults.get(i));
+            if (r.isSilent()) continue;
+            if (r.getMolecule() != null) {
+                if (r.getRule() != null) {
+                    System.out.println(r.getRule());
+                    System.out.println(r.getMolecule().getID());
+                    if (residues.indexOf(r.getMolecule()) == -1) {
+                        residues.add(r.getMolecule());
+                        r.getMolecule().setProperty("SUFFIX", "_("+residues.size()+")");                        
+                    }
+                }
+            }            
+        }
+        return residues;
+        */
+    }
+
+	public Hashtable<String,String> getExplanation(IAtomContainer mol) throws DecisionResultException {
+		Hashtable<String,String> b = new  Hashtable<String,String>();
+        ArrayList<IAtomContainer> residues = getAllAssignedMolecules();
+        IAtomContainer originalMol = getOriginalMolecule();
+		try {
+		    if (status.isEstimated()) {
+		    	for (int i=0;i < ruleResults.size();i++) {
+		    		RuleResult r = ((RuleResult)ruleResults.get(i));
+		    		if (r.isSilent()) continue;
+
+		    		if ((r.getCategory() == null) 
+		    			|| (r.getRule() instanceof IAlertCounter)
+		    			|| (
+		    			(r.getRule() instanceof DecisionNode) && (((DecisionNode)r.getRule()).getRule() instanceof IAlertCounter)
+		    			)
+		    			) { //not a leaf node or an alert
+		    			if (r.isResult())
+		    				b.put(r.getRule().getID(),Answers.toString(Answers.YES));
+		    			else 
+		    				b.put(r.getRule().getID(),Answers.toString(Answers.NO));
+		    		}
+		    		//Use this to get descriptor values 
+                    
+		    		if (r.getMolecule() != null) {
+                        
+                        Object suffix = "";
+                        IDescriptorBased rule = null;
+                        if (rule instanceof IDescriptorBased) 
+                            rule = (IDescriptorBased) r.getRule();
+                        else if ((r.getRule() instanceof DecisionNode) &&
+                             ((DecisionNode)r.getRule()).getRule() instanceof IDescriptorBased)
+                            rule = (IDescriptorBased) ((DecisionNode)r.getRule()).getRule();
+                        
+
+                        if (rule != null) {
+
+    		    			for (int d=0; d< descriptors.length;d++) {
+    		    				Object n= r.getMolecule().getProperty(descriptors[d]);
+    		    				if (n!= null) {
+                                    if ((rule != null) && rule.isCalculated(descriptors[d])) { 
+                                        
+                                        if (originalMol == r.getMolecule())
+                                            suffix = "";
+                                        else {
+                                            suffix = r.getMolecule().getProperty(SUFFIX);                                            
+                                            if ((suffix == null) &&
+                                                (residues.indexOf(r.getMolecule()) == -1) ) {
+                                                residues.add(r.getMolecule());
+                                                
+                                                r.getMolecule().setProperty(SUFFIX, "_("+residues.size()+")");
+                                                suffix = r.getMolecule().getProperty(SUFFIX);
+                                            }
+                                            if (suffix == null) suffix = "";
+                                        }
+        		    					mol.setProperty(descriptors[d]+suffix, n);
+                             
+                                    }
+                                }
+    		    					
+    		    			}
+                            suffix = r.getMolecule().getProperty(SUFFIX);
+                            if (suffix == null) suffix = "";
+                            for (int d=0; d< qsar.length;d++) {
+                                Object n= r.getMolecule().getProperty(qsar[d]);
+                                if (n!= null)
+                                    if ((rule != null) && rule.isCalculated(qsar[d]))  
+                                    mol.setProperty(qsar[d]+suffix, n
+                                            );
+                                    
+                            }		
+                        }
+                        
+		    		}
+		    	}
+		    	
+		    } else if (status.isEstimating()) {
+		        b.put(ProgressStatus._eResultIsEstimating,"YES");
+		        
+		    }   else if (status.isError()) {
+		        b.put(ProgressStatus._eError,status.getErrMessage());
+		    }
+
+            residues.clear();
+		//} catch (DecisionMethodException x) {
+			//throw new DecisionResultException(x);
+		} catch (NullPointerException x) {
+			throw new DMethodNotAssigned(ProgressStatus._eMethodNotAssigned);
+		}
+		return b;
+	}
+	
+	public void addRuleResult(IDecisionRule rule, boolean value, IAtomContainer molecule)
+	throws DecisionResultException {
+			super.addRuleResult(rule, value,molecule);
+			if (rule instanceof RuleAlertsForGenotoxicCarcinogenicity)
+				setSilent(true);
+			else setSilent((rule instanceof DecisionNode) &&	
+					(
+				(((DecisionNode)rule).getRule() instanceof RuleAlertsForGenotoxicCarcinogenicity) ||
+				(((DecisionNode)rule).getRule() instanceof RuleAlertsNongenotoxicCarcinogenicity)
+
+				)
+				);
+				
+					
+	}
+	
+	@Override
+	protected boolean acceptCategory(IDecisionCategory category) {
+		
+		if (category == null) return false;
+		if (category instanceof CategoryPositiveAlertGenotoxic) {
+				removeCategory(new CategoryNoGenotoxicAlert());
+				return true;
+		} else	if (category instanceof CategoryPositiveAlertNongenotoxic) {
+			removeCategory(new CategoryNoNongenotoxicAlert());
+			return true;
+		} else if (category instanceof CategoryCarcinogen) {
+			removeCategory(new CategoryNotCarcinogen());
+		} else if (category instanceof CategoryMutagenTA100) {
+			removeCategory(new CategoryNonMutagen());			
+		} else if (category instanceof CategoryNotCarcinogen) {
+			int alert = assignedCategories.indexOf(new CategoryCarcinogen());
+			if (alert > -1) return false;
+		} else if (category instanceof CategoryNonMutagen) {
+			int alert = assignedCategories.indexOf(new CategoryMutagenTA100());
+			if (alert > -1) return false;
+		} 
+		
+		return true;
+	}
+	protected void removeCategory(IDecisionCategory category) {
+		int remove = assignedCategories.indexOf(category);
+		if (remove > -1)
+			assignedCategories.remove(remove);
+
+	}
+    public List<CategoryFilter> getFilters() {
+
+    	ArrayList<CategoryFilter> l = new ArrayList<CategoryFilter>();
+    	IDecisionCategories c = getDecisionMethod().getCategories();
+		for (int i=0; i < c.size();i++) 
+		try { 
+    		l.add(new CategoryFilter(c.get(i).toString(),Answers.toString(Answers.YES)));
+    		l.add(new CategoryFilter(c.get(i).toString(),Answers.toString(Answers.NO)));
+    	} catch (Exception x) {
+    		logger.log(Level.SEVERE,x.getMessage(),x);
+    	}
+    	return l;
+    }
+}
+
+/**
+ * workaround due to problem with XML serialization with Enums
+ * @author Nina Jeliazkova nina@acad.bg
+ *
+ */
+class Answers {
+	public static int NO=0;
+	public static int YES=1;
+	protected Answers() {
+		
+	}
+	public static String toString(int answer) {
+		switch (answer) {
+		case 0: return "NO";
+		case 1: return "YES";
+		default: return "";
+		}
+	}
+}

data/Toxtree-v2.6.13/src/mutant/rules/QSAR6Applicable.java

@@ -0,0 +1,162 @@
+/* QSAR6Applicable.java
+ * Author: Nina Jeliazkova
+ * Date: Feb 17, 2008 
+ * Revision: 0.1 
+ * 
+ * Copyright (C) 2005-2008  Nina Jeliazkova
+ * 
+ * Contact: nina@acad.bg
+ * 
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; either version 2.1
+ * 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 Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * 
+ */
+
+package mutant.rules;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IMolecularFormula;
+import org.openscience.cdk.tools.manipulator.MolecularFormulaManipulator;
+
+import toxTree.core.IDecisionInteractive;
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.tree.rules.smarts.RuleSMARTSubstructureCDK;
+import toxTree.ui.EditorFactory;
+import ambit2.core.data.MoleculeTools;
+
+public class QSAR6Applicable extends RuleSMARTSubstructureCDK implements IDecisionInteractive{
+    /**
+     * 
+     */
+    private static final long serialVersionUID = 1840810866408347284L;
+    protected static String aromatic_amine="For QSAR6 calculation of mutagenicity of aromatic amines, molecules that contain also NA_27 (aromatic nitro), should be excluded.";
+    protected UserOptions options = UserOptions.NO;
+    protected PropertyChangeListener listener;
+    
+    public UserOptions getOptions() {
+		return options;
+	}
+	public void setOptions(UserOptions options) {
+		this.options = options;
+	}
+	public QSAR6Applicable() throws Exception {
+
+            setContainsAllSubstructures(true);
+            
+            StringBuffer b = new StringBuffer();
+            StringBuffer a = new StringBuffer();
+            a.append("c");
+            
+            b.append("[");
+            b.append("c");
+            
+            for (int i=0; i < 6; i++) {
+                a.append("c");
+
+                b.append(";");
+                b.append("!$(");
+                b.append(a.toString());
+                b.append("[N+]([O-])=O");
+                b.append(")");
+            }
+            b.append("]");
+            b.append("[");
+            b.append("NX3v3");
+
+            b.append("]");            
+            addSubstructure(aromatic_amine,b.toString());
+            /*
+[c;!$(cc[SX4](=[OX1])(=[OX1])([O-,OX2H1]));!$(cc[n,o,s,p]);!$(ccc[SX4](=[OX1])(=[OX1])([O-,OX2H1]));!$(ccc[n,o,s,p]);!$(cccc[SX4](=[OX1])(=[OX1])([O-,OX2H1]));!$(cccc[n,o,s,p]);!$(ccccc[SX4](=[OX1])(=[OX1])([O-,OX2H1]));!$(ccccc[n,o,s,p]);!$(cccccc[SX4](=[OX1])(=[OX1])([O-,OX2H1]));!$(cccccc[n,o,s,p]);!$(ccccccc[SX4](=[OX1])(=[OX1])([O-,OX2H1]));!$(ccccccc[n,o,s,p])][NX3v3;!$(N[CX4H2][OX2H1]);!$(N(CC[Cl,Br,F,I])(CC[Cl,Br,F,I]));!$(NN);!$(N([#1,C])N=O);!$(NN=N);!$(N[OX2H1])]
+            */
+            setID("QSAR6 applicable?");
+            setTitle("Aromatic amines without nitro group");
+            StringBuffer e = new StringBuffer();
+            e.append(aromatic_amine);
+/**
+ 
+ */
+            setExplanation(e.toString());
+            examples[0] = "c1ccc(N)cc1[N+](=O)[O-]";
+            examples[1] = "c1ccccc1N"; 
+            setListener(EditorFactory.getInstance().createApplyRuleOptions());
+            setInteractive(true);
+    }
+    @Override
+    protected boolean isAPossibleHit(IAtomContainer mol, IAtomContainer processedObject) throws DecisionMethodException  {
+		IMolecularFormula formula = MolecularFormulaManipulator.getMolecularFormula(mol);
+		return 
+		MolecularFormulaManipulator.containsElement(formula,MoleculeTools.newElement(formula.getBuilder(),"N"));
+    }
+    /*
+	public JComponent optionsPanel(IAtomContainer atomContainer) {
+		return options.optionsPanel("Skip this rule?","If yes, the answer of the rule will always be YES, regardless of the structure.",  getID(), atomContainer);
+	
+	}
+*/
+	public void setInteractive(boolean value) {
+		options.setInteractive(value);
+		
+	}
+	public void setSkipRule(boolean value) {
+		options.setAnswer(value);
+		
+	}
+	public boolean isSkipRule() {
+		return options.getAnswer();
+	}
+	
+	@Override
+	public boolean verifyRule(IAtomContainer mol) throws DecisionMethodException {
+        if (getInteractive() && (getListener() !=null)) {
+        	getListener().propertyChange(new PropertyChangeEvent(
+        			this,
+        			"Skip this rule?",
+        			"If yes, the answer of the rule will always be YES, regardless of the structure.",
+        			mol));
+
+        } 
+		if (isSkipRule()) {
+			logger.finer("Skip the rule");
+			return true;			
+		} else return super.verifyRule(mol);
+        /*
+		if (getInteractive()) 
+			JOptionPane.showMessageDialog(null, optionsPanel(mol),getTitle(),JOptionPane.PLAIN_MESSAGE,null);
+		if (isSkipRule()) {
+			logger.info("Skip the rule");
+			return true;			
+		} else return super.verifyRule(mol);
+		*/
+	}
+	public boolean getInteractive() {
+		return options.isInteractive();
+	}
+	public PropertyChangeListener getListener() {
+		return listener;
+	}
+	public void setListener(PropertyChangeListener listener) {
+		this.listener = listener;
+	}
+	public void removeListener() {
+		this.listener = null;
+		
+	}
+}