toxtree 0.0.1

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/categories/RequireCompoundSpecificToxicityData.java

@@ -0,0 +1,25 @@
+package toxtree.plugins.kroes.categories;
+
+import toxTree.tree.DefaultCategory;
+
+public class RequireCompoundSpecificToxicityData extends DefaultCategory
+{
+
+    public RequireCompoundSpecificToxicityData()
+    {
+        this("Risk assessment requires compound-specific toxicity data", 3);
+    }
+
+    public RequireCompoundSpecificToxicityData(String name, int id)
+    {
+        super(name, id);
+    }
+
+    private static final long serialVersionUID = 0xf8e2d8d0ba9a765fL;
+    
+    
+    @Override
+    public CategoryType getCategoryType() {
+    	return CategoryType.InconclusiveCategory;
+    }
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule10.java

@@ -0,0 +1,25 @@
+package toxtree.plugins.kroes.rules;
+
+import toxTree.tree.cramer.CramerClass2;
+
+/**
+ * 
+ * @author nina
+ * Is the compound in Cramer structural class II?
+ */
+public class KroesRule10 extends KroesRule8 {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -8716961767047489196L;
+	public KroesRule10() {
+		setID("Q10");
+		setTitle("Is the compound in Cramer structural class II?");
+		setExplanation(getTitle());
+		category = new CramerClass2();
+		examples[0]="O=C2OC(COc1ccccc1(OC))CN2";
+		examples[1]="O=C1C=COC(=C1(O))CC";		
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule11.java

@@ -0,0 +1,24 @@
+package toxtree.plugins.kroes.rules;
+
+
+/**
+ * 
+ * @author nina
+ * Does estimated intake exceed 540 \u00B5g/day ?
+ */
+public class KroesRule11 extends RuleVerifyIntake {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -6146027047205787207L;
+	public KroesRule11() {
+		super();
+		setID("Q11");
+		setTitle("Does estimated intake exceed 540 \u00B5g/day ?");
+		setExplanation(getTitle());
+		propertyStaticValue = 540.0;
+		
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule12.java

@@ -0,0 +1,23 @@
+package toxtree.plugins.kroes.rules;
+
+
+/**
+ * Does estimated intake exceed 1800 \u00B5g/day ?
+ * @author nina
+ *
+ */
+public class KroesRule12 extends RuleVerifyIntake {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -1262200903658375242L;
+	public KroesRule12() {
+		super();
+		setID("Q12");
+		setTitle("Does estimated intake exceed 1800 \u00B5g/day ?");
+		setExplanation(getTitle());
+		propertyStaticValue = 1800.0;
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule2.java

@@ -0,0 +1,23 @@
+package toxtree.plugins.kroes.rules;
+
+import toxTree.tree.rules.RuleVerifyAlertsCounter;
+
+/**
+ * Are there structural alerts that raise concern for potential genotoxicity?
+ * @author nina
+ *
+ */
+public class KroesRule2 extends RuleVerifyAlertsCounter {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -7061116252242308444L;
+	public KroesRule2() {
+		super();
+		setID("Q2");
+		setTitle("Are there structural alerts that raise concern for potential genotoxicity?");
+		setExplanation("At least one structural alert SA1-SA30");
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule3.java

@@ -0,0 +1,33 @@
+package toxtree.plugins.kroes.rules;
+
+import toxTree.tree.rules.smarts.RuleSMARTSSubstructureAmbit;
+import ambit2.smarts.query.SMARTSException;
+
+
+/**
+ * Is the chemical an aflatoxin-like, azoxy-, or N-nitroso compound
+ * @author nina
+ *
+ */
+public class KroesRule3 extends RuleSMARTSSubstructureAmbit {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -6122710066223986724L;
+	public KroesRule3() {
+		setID("Q3");
+		setTitle("Is the chemical an aflatoxin-like, azoxy-, or N-nitroso compound");
+		setExplanation(getTitle());
+		try {
+			addSubstructure("aflatoxin","COC1=C2C3=C(C(=O)OCC3)C(=O)OC2=C2C3C=COC3OC2=C1");
+			addSubstructure("azoxy","N=[N+][O-]");
+			addSubstructure("N-nitroso","NN=O");
+		} catch (SMARTSException x) {
+			smartsPatterns.clear();
+		}
+		examples[0] = "c1ccccc1N=Nc2ccccc2";
+		examples[1] = "COC1=C2C3=C(C(=O)OCC3)C(=O)OC2=C2C3C=COC3OC2=C1";
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule4.java

@@ -0,0 +1,24 @@
+package toxtree.plugins.kroes.rules;
+
+
+/**
+ * Does estimated intake exceed TTC of 0.15 \u00B5g/day ?
+ * @author nina
+ *
+ */
+public class KroesRule4 extends RuleVerifyIntake {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 3075417665758907375L;
+	public KroesRule4() {
+		super();
+		setID("Q4");
+		setTitle("Does estimated intake exceed TTC of 0.15 \u00B5g/day ?");
+		setExplanation(getTitle());
+		propertyStaticValue =0.15;
+	}
+
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule5.java

@@ -0,0 +1,25 @@
+package toxtree.plugins.kroes.rules;
+
+
+/**
+ * Does estimated intake exceed TTC of 1.5 mcg/day ?
+ * @author nina
+ *
+ */
+public class KroesRule5 extends RuleVerifyIntake {
+	
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -553860642437002004L;
+	public KroesRule5() {
+		super();
+		setID("Q5");
+		setTitle("Does estimated intake exceed TTC of 1.5 \u00B5g/day ?");
+		setExplanation(getTitle());
+		propertyStaticValue = 1.5;
+	}
+
+
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule6.java

@@ -0,0 +1,22 @@
+package toxtree.plugins.kroes.rules;
+
+import cramer2.rules.RuleUnchargedOrganophosphates;
+
+/**
+ * Is the compound an organophosphate?
+ * @author nina
+ *
+ */
+public class KroesRule6 extends RuleUnchargedOrganophosphates {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 1776897873563751556L;
+	public KroesRule6() {
+		setID("Q6");
+		setTitle("Is the compound an organophosphate?");
+		setExplanation(getTitle());
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule7.java

@@ -0,0 +1,23 @@
+package toxtree.plugins.kroes.rules;
+
+
+/**
+ *Does estimated intake exceed TTC of 18\u00B5g/day ?
+ * @author nina
+ *
+ */
+public class KroesRule7 extends RuleVerifyIntake {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 5853268905275906969L;
+	public KroesRule7() {
+		super();
+		setID("Q7");
+		setTitle("Does estimated intake exceed TTC of 18\u00B5g/day ?");
+		setExplanation(getTitle());
+		propertyStaticValue = 18.0;
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule8.java

@@ -0,0 +1,65 @@
+package toxtree.plugins.kroes.rules;
+
+import net.idea.modbcum.i.processors.IProcessor;
+
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.renderer.selection.IChemObjectSelection;
+
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.exceptions.DecisionResultException;
+import toxTree.tree.AbstractRule;
+import toxTree.tree.DefaultCategory;
+import toxTree.tree.cramer.CramerClass3;
+import toxTree.tree.cramer.CramerRules;
+import toxTree.tree.cramer.CramerTreeResult;
+
+/**
+ * Is the compound in Cramer structural class III?
+ * @author nina
+ *
+ */
+public class KroesRule8 extends AbstractRule {
+	protected CramerRules cramerRules = null;
+	protected CramerTreeResult cramerResults = null;
+	protected DefaultCategory category;
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 9074211771162398484L;
+	public KroesRule8() {
+		setID("Q8");
+		setTitle("Is the compound in Cramer structural class III?");
+		setExplanation(getTitle());
+		category = new CramerClass3();
+		examples[1]="O=C2OC(COc1ccccc1(OC))CN2";
+		examples[0]="O=C1C=COC(=C1(O))CC";
+	}
+	public boolean verifyRule(IAtomContainer mol)
+			throws DecisionMethodException {
+		if (cramerResults == null) cramerResults = new toxTree.tree.cramer.CramerTreeResult();
+		Object result = mol.getProperty(cramerResults.getResultPropertyNames()[0]);
+		if (result == null) { // estimate
+			if (cramerRules==null) cramerRules = new CramerRules();
+			cramerResults.setDecisionMethod(cramerRules);
+			cramerRules.classify(mol,cramerResults);
+			try {
+				cramerResults.assignResult(mol);
+				result = mol.getProperty(cramerResults.getResultPropertyNames()[0]);
+				return result.equals(category.toString());
+			} catch (DecisionResultException x) {
+				throw new DecisionMethodException(x);
+			} catch (Exception x) {
+				throw new DecisionMethodException(x);
+			}
+		} else {
+			return result.equals(category.toString());
+		}
+	}
+	@Override
+	public boolean isImplemented() {
+		return true;
+	}
+	public IProcessor<IAtomContainer, IChemObjectSelection> getSelector() {
+		return null;
+	}
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/KroesRule9.java

@@ -0,0 +1,24 @@
+package toxtree.plugins.kroes.rules;
+
+
+/**
+ * 
+ * @author nina
+ *
+ */
+public class KroesRule9 extends RuleVerifyIntake {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 9202526263556621253L;
+	public KroesRule9() {
+		super();
+		setID("Q9");
+		setTitle("Does estimated intake exceed 90 \u00B5g/day ?");
+		setExplanation(getTitle());
+		propertyStaticValue = 90.0;
+	}
+
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/MyOrderQueryBond.java

@@ -0,0 +1,28 @@
+
+package toxtree.plugins.kroes.rules;
+
+import org.openscience.cdk.interfaces.IBond;
+import org.openscience.cdk.isomorphism.matchers.IQueryAtom;
+import org.openscience.cdk.isomorphism.matchers.OrderQueryBond;
+
+public class MyOrderQueryBond extends OrderQueryBond
+{
+
+    public MyOrderQueryBond()
+    {
+    }
+
+    public MyOrderQueryBond(IQueryAtom atom1, IQueryAtom atom2, Order order)
+    {
+        super(atom1, atom2, order);
+    }
+
+    public boolean matches(IBond bond)
+    {
+        if(getOrder() == bond.getOrder())
+            return true;
+        return getFlag(4) && bond.getFlag(4);
+    }
+
+    private static final long serialVersionUID = 0x382d4471e3895945L;
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/kroes/rules/RuleKroesFig1Q1.java

@@ -0,0 +1,305 @@
+package toxtree.plugins.kroes.rules;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Iterator;
+import java.util.List;
+import java.util.logging.Level;
+
+import org.openscience.cdk.CDKConstants;
+import org.openscience.cdk.exception.CDKException;
+import org.openscience.cdk.interfaces.IAtom;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IBond;
+import org.openscience.cdk.interfaces.IBond.Order;
+import org.openscience.cdk.interfaces.IElement;
+import org.openscience.cdk.interfaces.IMolecularFormula;
+import org.openscience.cdk.interfaces.IMolecule;
+import org.openscience.cdk.io.iterator.IIteratingChemObjectReader;
+import org.openscience.cdk.io.iterator.IteratingMDLReader;
+import org.openscience.cdk.io.iterator.IteratingSMILESReader;
+import org.openscience.cdk.isomorphism.matchers.IQueryAtom;
+import org.openscience.cdk.isomorphism.matchers.IQueryAtomContainer;
+import org.openscience.cdk.isomorphism.matchers.QueryAtomContainer;
+import org.openscience.cdk.isomorphism.matchers.SymbolQueryAtom;
+import org.openscience.cdk.isomorphism.matchers.SymbolSetQueryAtom;
+import org.openscience.cdk.isomorphism.matchers.smarts.AromaticQueryBond;
+import org.openscience.cdk.silent.SilentChemObjectBuilder;
+import org.openscience.cdk.tools.manipulator.MolecularFormulaManipulator;
+
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.query.FunctionalGroups;
+import toxTree.query.MolAnalyser;
+import toxTree.tree.rules.RuleSubstructures;
+import ambit2.core.io.IteratingDelimitedFileReader;
+
+/**
+ * TODO refactor with SMARTS
+ * @author nina
+ *
+ */
+
+public class RuleKroesFig1Q1 extends RuleSubstructures
+{
+
+    public RuleKroesFig1Q1()
+    {
+        init();
+        readStream(getConfiguration(), config);
+    }
+
+    public RuleKroesFig1Q1(InputStream stream, String format)
+    {
+        init();
+        readStream(stream, format);
+    }
+
+    public RuleKroesFig1Q1(File file)
+    {
+        init();
+        logger.fine("Will be using file\t"+ file.getAbsoluteFile());
+        String f = file.getPath().toLowerCase();
+        if(file.exists() && (f.endsWith(".sdf") || f.endsWith(".smi") || f.endsWith(".csv")))
+            try
+            {
+                FileInputStream fStream = new FileInputStream(file);
+                readStream(fStream, file.getPath().toLowerCase());
+            }
+            catch(FileNotFoundException x)
+            {
+                logger.log(Level.SEVERE,x.getMessage(),x);
+            }
+        else
+            logger.fine("File does not exists or unsupported format\t"+ file.getAbsoluteFile());
+    }
+
+    protected void init()
+    {
+    	setID("Q1");
+        title = "Is the substance a non-essential metal or metal containing compound, or is it a polyhalogenated dibenzodioxin, -dibenzofuran, or -biphenyl?";
+        explanation.append("<html>");
+        explanation.append(title);
+        explanation.append("<br>");
+        explanation.append("Essential metals: ");
+        for(int i = 0; i < me_essential.length; i++)
+        {
+            if(i > 0)
+                explanation.append(',');
+            explanation.append(me_essential[i]);
+        }
+
+        explanation.append("<br>");
+        explanation.append("Non-essential metals: ");
+        for(int i = 0; i < me_nonessential.length; i++)
+        {
+            if(i > 0)
+                explanation.append(',');
+            explanation.append(me_nonessential[i]);
+        }
+
+        explanation.append("</html>");
+        examples[0] = "c1ccc2Oc3c(Oc2(c1))cccc3Cl";
+        examples[1] = "O1c3cccc(c3(Oc2c1cccc2Cl))Cl";
+    }
+
+    protected void readStream(InputStream fStream, String format)
+    {
+        try
+        {
+            IIteratingChemObjectReader reader;
+            if(format.endsWith(".sdf"))
+                reader = new IteratingMDLReader(fStream, SilentChemObjectBuilder.getInstance());
+            else
+            if(format.endsWith(".csv"))
+                reader = new IteratingDelimitedFileReader(fStream);
+            else
+            if(format.endsWith(".smi"))
+            {
+                reader = new IteratingSMILESReader(fStream);
+            } else
+            {
+                logger.severe("Unsupported format");
+                fStream.close();
+                return;
+            }
+            int r = 0;
+            while(reader.hasNext()) 
+            {
+                r++;
+                Object o = reader.next();
+                if(o instanceof IAtomContainer)
+                {
+                    IMolecule m = (IMolecule)o;
+                    if(m.getAtomCount() > 0)
+                        try
+                        {
+                            MolAnalyser.analyse(m);
+                            IQueryAtomContainer q = createQueryContainer(m);
+                            addSubstructure(q);
+                            q.setID(m.getProperty("Names").toString());
+                        }
+                        catch(Exception exception) { }
+                }
+            }
+            logger.finer(r + " structures read from " + format);
+            reader.close();
+            reader = null;
+        }
+        catch(IOException x)  {
+            logger.log(Level.SEVERE,x.getMessage(),x);
+        }
+        catch(CDKException x)  {
+            logger.log(Level.SEVERE,x.getMessage(),x);
+        }
+        
+    }
+
+    public static IQueryAtomContainer createQueryContainer(IAtomContainer container)
+    {
+        IQueryAtomContainer queryContainer = new QueryAtomContainer();
+        Iterator<IAtom> atoms = container.atoms().iterator();
+        while (atoms.hasNext()) {
+        	IAtom atom  = atoms.next();
+        
+            if(atom.getSymbol().equals("H"))
+            {
+                SymbolSetQueryAtom a = new SymbolSetQueryAtom();
+                a.setSymbol("Hal");
+                a.addSymbol("Hal");
+                a.addSymbol("H");
+                for(int j = 0; j < halogens.length; j++)
+                    a.addSymbol(halogens[j]);
+
+                queryContainer.addAtom(a);
+            } else
+                queryContainer.addAtom(new SymbolQueryAtom(atom));
+        }
+        Iterator<IBond> bonds = container.bonds().iterator();
+        while (bonds.hasNext())
+        {
+        	IBond bond = bonds.next();
+            int index1 = container.getAtomNumber(bond.getAtom(0));
+            int index2 = container.getAtomNumber(bond.getAtom(1));
+            if(bond.getFlag(CDKConstants.ISAROMATIC))
+            {
+                AromaticQueryBond b = new AromaticQueryBond((IQueryAtom)queryContainer.getAtom(index1), (IQueryAtom)queryContainer.getAtom(index2), Order.SINGLE);
+                b.setFlag(CDKConstants.ISAROMATIC, true);
+                queryContainer.addBond(b);
+            } else
+            {
+                MyOrderQueryBond q = new MyOrderQueryBond((IQueryAtom)queryContainer.getAtom(index1), (IQueryAtom)queryContainer.getAtom(index2), bond.getOrder());
+                q.setFlag(CDKConstants.ISAROMATIC, bond.getFlag(CDKConstants.ISAROMATIC));
+                queryContainer.addBond(q);
+            }
+        }
+
+        return queryContainer;
+    }
+
+    protected static InputStream getConfiguration()
+    {
+        return toxtree.plugins.kroes.rules.RuleKroesFig1Q1.class.getResourceAsStream(config);
+    }
+
+    public boolean isImplemented()
+    {
+        return true;
+    }
+
+
+    public boolean verifyRule(IAtomContainer mol) throws DecisionMethodException
+    {
+	    IMolecularFormula formula = MolecularFormulaManipulator.getMolecularFormula(mol);
+        List<IElement> elements = MolecularFormulaManipulator.elements(formula);
+        int halogensFound = 0;
+        for(int i = 0; i < elements.size(); i++)
+        {
+            String element = elements.get(i).getSymbol();
+            for(int m = 0; m < me_essential.length; m++)
+                if(element.equals(me_essential[m]))
+                {
+                    logger.finer("Essential metal\t"+ me_essential[m]+ "\tfound.");
+                    return true;
+                }
+
+            for(int m = 0; m < me_nonessential.length; m++)
+                if(element.equals(me_nonessential[m]))
+                {
+                    logger.finer("Non-essential metal\t"+ me_nonessential[m]+ "\tfound.");
+                    return true;
+                }
+
+            for(int m = 0; m < halogens.length; m++)
+                if(element.equals(halogens[m]))
+                {
+                    logger.finer("Halogen \t" + halogens[m]+ "\tfound.");
+                    halogensFound += MolecularFormulaManipulator.getElementCount(formula,elements.get(i));
+                }
+
+        }
+
+        if(halogensFound < 2)
+        {
+            logger.finer("Not a polyhalogenated compound");
+            return false;
+        }
+        logger.finer("Polyhalogenated compound\t"+ Integer.toString(halogensFound)+ "\thalogens found");
+        //print(mol);
+        for(int i = 0; i < query.getAtomContainerCount(); i++)
+        {
+            logger.finer("Compare with "+ query.getAtomContainer(i).getID());
+            if(FunctionalGroups.isSubstance(mol, query.getAtomContainer(i)))
+                return true;
+        }
+
+        logger.fine("Compared with "+ Integer.toString(query.getAtomContainerCount())+ " structures");
+        logger.fine("NOT a "+ explanation.toString());
+        return false;
+    }
+    /*
+    protected void print(IAtomContainer a)
+    {
+        logger.info(a.getID());
+        for(int i = 0; i < a.getAtomCount(); i++)
+        {
+            System.out.print((i + 1) + "\t" + a.getAtom(i) + "\t");
+            boolean f[] = a.getAtom(i).getFlags();
+            for(int j = 0; j < f.length; j++)
+                System.out.print(f[j] + "\t");
+
+            System.out.println();
+        }
+
+        for(int i = 0; i < a.getBondCount(); i++)
+        {
+            System.out.print((i + 1) + "\t" + a.getBond(i) + "\t");
+            System.out.print(a.getBond(i).getOrder() + "\t");
+            boolean f[] = a.getBond(i).getFlags();
+            for(int j = 0; j < f.length; j++)
+                System.out.print(f[j] + "\t");
+
+            System.out.println();
+        }
+
+        logger.info("");
+    }
+	*/
+    public static transient String halogens[] = {
+        "F", "Cl", "Br", "I"
+    };
+    public static transient String me_essential[] = {
+        "Na", "Mg", "K", "Ca", "P", "Mn", "Fe", "Cu", "Zn", "Co", 
+        "Ni"
+    };
+    public static transient String me_nonessential[] = {
+        "Cr", "Hg", "Pb", "V", "Al", "Ag", "Cd", "As", "B", "Ti", 
+        "Se", "Sn", "Sb", "Be", "Zr", "Nb", "Mo", "Te", "Ba", "W", 
+        "Au", "Bi"
+    };
+    public static transient String config = "/kroes/KroesFig1Q1.sdf";
+    private static final long serialVersionUID = 0x13adfd43291d6b05L;
+
+}