toxtree 0.0.1

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/categories/SitesRank1.java

@@ -0,0 +1,45 @@
+/*
+Copyright (C) 2005-2013
+
+Contact: www.ideaconsult.net
+
+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 toxtree.plugins.smartcyp.categories;
+
+import toxTree.tree.DefaultCategory;
+import toxtree.plugins.smartcyp.SMARTCypTreeResult;
+
+public class SitesRank1 extends DefaultCategory {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -8169535167365480219L;
+	public SitesRank1() {
+		super(String.format(SMARTCypTreeResult.FORMAT, "",1, "sites"), 1);
+		setExplanation("SMARTCyp primary sites of metabolism found");
+		setThreshold("");
+	}
+	@Override
+	public CategoryType getCategoryType() {
+		return CategoryType.InconclusiveCategory;
+	}
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/categories/SitesRank2.java

@@ -0,0 +1,24 @@
+package toxtree.plugins.smartcyp.categories;
+
+import toxTree.tree.DefaultCategory;
+import toxtree.plugins.smartcyp.SMARTCypTreeResult;
+
+public class SitesRank2 extends DefaultCategory {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 6219341311785787592L;
+
+	public SitesRank2() {
+		super(String.format(SMARTCypTreeResult.FORMAT, "",2, "sites"), 2);
+		setExplanation("SMARTCyp secondary sites of metabolism found");
+		setThreshold("");
+	}
+	
+	@Override
+	public CategoryType getCategoryType() {
+		return CategoryType.InconclusiveCategory;
+	}
+
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/categories/SitesRank3.java

@@ -0,0 +1,46 @@
+/*
+Copyright (C) 2005-2013
+
+Contact: www.ideaconsult.net
+
+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 toxtree.plugins.smartcyp.categories;
+
+import toxTree.tree.DefaultCategory;
+import toxtree.plugins.smartcyp.SMARTCypTreeResult;
+
+public class SitesRank3 extends DefaultCategory  {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 4437712178229753247L;
+
+	public SitesRank3() {
+		super(String.format(SMARTCypTreeResult.FORMAT, "",3, "sites"), 3);
+		setExplanation("SMARTCyp tertiary sites of metabolism found");
+		setThreshold("");
+	}
+	
+	@Override
+	public CategoryType getCategoryType() {
+		return CategoryType.InconclusiveCategory;
+	}
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/rules/MetaboliteGenerator.java

@@ -0,0 +1,183 @@
+package toxtree.plugins.smartcyp.rules;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+
+import org.openscience.cdk.CDKConstants;
+import org.openscience.cdk.interfaces.IAtom;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IAtomContainerSet;
+import org.openscience.cdk.interfaces.IAtomType;
+import org.openscience.cdk.interfaces.IBond;
+import org.openscience.cdk.silent.SilentChemObjectBuilder;
+import org.openscience.cdk.smiles.FixBondOrdersTool;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
+
+import toxTree.core.IMetaboliteGenerator;
+import toxTree.tree.AbstractRule;
+import toxTree.tree.RuleResult;
+import ambit2.smarts.IAcceptable;
+import ambit2.smarts.SMIRKSManager;
+import ambit2.smarts.SMIRKSReaction;
+import ambit2.smarts.SmartsConst;
+import dk.smartcyp.core.MoleculeKU.SMARTCYP_PROPERTY;
+import dk.smartcyp.core.SMARTSData;
+import dk.smartcyp.smirks.SMARTCYPReaction;
+
+public abstract class MetaboliteGenerator extends AbstractRule implements
+		IMetaboliteGenerator, IAcceptable {
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -3202810538351239202L;
+	protected transient SMIRKSManager smrkMan;
+	protected int rank;
+	protected transient ResourceBundle bundle;
+	
+	public MetaboliteGenerator() {
+		super();
+		bundle = ResourceBundle.getBundle(getClass().getName(),Locale.ENGLISH,getClass().getClassLoader());
+	}
+	public int getRank() {
+		return rank;
+	}
+
+	public void setRank(int rank) {
+		this.rank = rank;
+	}
+
+	@Override
+	public IAtomContainerSet getProducts(IAtomContainer reactant,
+			RuleResult ruleResult) throws Exception {
+		IAtomContainerSet products = null;
+	//	AtomConfigurator cfg = new AtomConfigurator();
+		if (smrkMan == null) {
+			smrkMan = new SMIRKSManager(SilentChemObjectBuilder.getInstance());
+			//smrkMan.setSSMode(SmartsConst.SSM_NON_IDENTICAL_FIRST);
+			smrkMan.setSSMode(SmartsConst.SSM_NON_IDENTICAL);
+			smrkMan.FlagFilterEquivalentMappings = true;
+		}
+		List<SMARTCYPReaction> reactions = new ArrayList<SMARTCYPReaction>();
+		for (IAtom atom : reactant.atoms()) {
+
+			
+			Number atom_rank = SMARTCYP_PROPERTY.Ranking.getNumber(atom);
+			if (atom_rank == null)
+				continue;
+			if (atom_rank.intValue() != getRank())
+				continue;
+			
+			SMARTSData data = SMARTCYP_PROPERTY.Energy.getData(atom);
+			if (data == null) {
+				if (products == null)
+					products = SilentChemObjectBuilder.getInstance()
+							.newInstance(IAtomContainerSet.class);
+				//IAtomContainer product = NoNotificationChemObjectBuilder.getInstance().newInstance(IAtomContainer.class);
+				//product.setID(String.format("No energy for rank 1 atom!"));
+				//products.addAtomContainer(product);
+				continue;
+			}
+				//throw new Exception("Energy property missing for atom of rank "		+ atom_rank);
+			if (reactions.indexOf(data.getReaction()) < 0)
+				reactions.add(data.getReaction());
+		}
+
+		for (SMARTCYPReaction reaction : reactions) {
+
+			SMIRKSReaction smr = smrkMan.parse(reaction.getSMIRKS());
+
+			IAtomContainer product = reactant; //(IAtomContainer) reactant.clone();
+			IAtomContainerSet rproducts = smrkMan.applyTransformationWithSingleCopyForEachPos(product, this, smr);
+			
+			if (rproducts!=null) {
+			//if (smrkMan.applyTransformation(product, this, smr)) {
+				
+				if (products == null)
+					products = SilentChemObjectBuilder.getInstance().newInstance(IAtomContainerSet.class);
+				
+				FixBondOrdersTool fbt = new FixBondOrdersTool();
+				for (IAtomContainer ac : rproducts.atomContainers()) {
+					ac.setID(reaction.toString());
+					
+					for (IAtom atom: ac.atoms()) {
+
+						atom.setFormalNeighbourCount((Integer) CDKConstants.UNSET);
+					      atom.setAtomTypeName((String) CDKConstants.UNSET);
+				            atom.setMaxBondOrder((IBond.Order) CDKConstants.UNSET);
+				            atom.setBondOrderSum((Double) CDKConstants.UNSET);
+				            atom.setHybridization((IAtomType.Hybridization) CDKConstants.UNSET);
+					 //  atom.setBondOrderSum(null);
+					  // atom.setValency(null);
+					   
+					   atom.setFlag(CDKConstants.ISAROMATIC, false);
+
+						/*
+					      atom.setAtomTypeName((String) CDKConstants.UNSET);
+				            atom.setMaxBondOrder((IBond.Order) CDKConstants.UNSET);
+				            atom.setBondOrderSum((Double) CDKConstants.UNSET);
+				            atom.setCovalentRadius((Double) CDKConstants.UNSET);
+				            atom.setValency((Integer) CDKConstants.UNSET);
+				           // atom.setFormalCharge((Integer) CDKConstants.UNSET);
+				            atom.setHybridization((IAtomType.Hybridization) CDKConstants.UNSET);
+				            atom.setFormalNeighbourCount((Integer) CDKConstants.UNSET);
+				            atom.setFlag(CDKConstants.IS_HYDROGENBOND_ACCEPTOR, false);
+				            atom.setFlag(CDKConstants.IS_HYDROGENBOND_DONOR, false);
+				            atom.setProperty(CDKConstants.CHEMICAL_GROUP_CONSTANT, CDKConstants.UNSET);
+				            atom.setFlag(CDKConstants.ISAROMATIC, false);
+				            atom.setProperty("org.openscience.cdk.renderer.color", CDKConstants.UNSET);
+				            atom.setAtomicNumber((Integer) CDKConstants.UNSET);
+				            atom.setExactMass((Double) CDKConstants.UNSET);			
+				            */			
+					}
+					for (IBond bond : ac.bonds()) {
+						bond.setFlag(CDKConstants.ISAROMATIC, false);
+					}
+					//AtomContainerManipulator.clearAtomConfigurations(ac); //not all!
+					AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(ac);
+					//if (ac instanceof IMolecule)
+					//	ac = fbt.kekuliseAromaticRings((IMolecule)ac);
+					//AtomContainerManipulator.percieveAtomTypesAndConfigureUnsetProperties(ac);
+					//CDKHueckelAromaticityDetector.detectAromaticity(ac);
+					
+				}
+				products.add(rproducts);
+				//product.setID(reaction.toString());
+	
+				//products.addAtomContainer(product);
+			} else {
+				if (products == null)
+					products = SilentChemObjectBuilder.getInstance()
+							.newInstance(IAtomContainerSet.class);
+				product = SilentChemObjectBuilder.getInstance().newInstance(IAtomContainer.class);
+				product.setID(String.format("Can't generate products! <br>%s<br>%s<br>%s",
+						reaction.name(),
+						reaction.getSMIRKS(),
+						smrkMan.getErrors()));
+				products.addAtomContainer(product);
+			}
+		}
+
+		return products;
+	}
+
+	@Override
+	public boolean accept(List<IAtom> atoms) {
+
+		boolean ok = false;
+		for (IAtom atom : atoms) {
+			Number atom_rank = SMARTCYP_PROPERTY.Ranking.getNumber(atom);
+			if (atom_rank == null)
+				continue;
+			if (atom_rank.intValue() == getRank())
+				ok = true; // any atom with rank 1 within this mapping
+		}
+		return ok;
+	}
+
+	@Override
+	public String getHelp(RuleResult ruleresult) {
+		return bundle.getString("metabolite_help");
+	}
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/rules/SMARTCYPRuleHigherRank.java

@@ -0,0 +1,20 @@
+package toxtree.plugins.smartcyp.rules;
+
+
+public class SMARTCYPRuleHigherRank extends SMARTCYPRuleRank1 {
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 2711634544165374724L;
+	public SMARTCYPRuleHigherRank() {
+		super(4);
+		setExplanation(String.format("Rank >= %d",rank));	
+		examples[0] = "C1C=CNC=C1";
+		examples[1] = "O=[N+]([O-])c4ccc1ccc2cccc3ccc4(c1c23)";
+		
+	}
+	protected boolean hasRank(int atom_rank) {
+		return atom_rank>=getRank();
+	}
+}

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/rules/SMARTCYPRuleHigherRank.properties

@@ -0,0 +1,2 @@
+title=SMARTCyp sites of metabolism with Rank>=4
+metabolite_help=<html><h3>Cytochrome P450-Mediated Drug Metabolism.</h3>Most probable metabolites, generated by reactions at the <br><b>SMARTCyp predicted site of metabolism with Rank > 3.</b><html>

data/Toxtree-v2.6.13/src/toxtree/plugins/smartcyp/rules/SMARTCYPRuleRank1.java

@@ -0,0 +1,244 @@
+package toxtree.plugins.smartcyp.rules;
+
+import net.idea.modbcum.i.exceptions.AmbitException;
+import net.idea.modbcum.i.processors.IProcessor;
+
+import org.openscience.cdk.aromaticity.CDKHueckelAromaticityDetector;
+import org.openscience.cdk.interfaces.IAtom;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IAtomContainerSet;
+import org.openscience.cdk.interfaces.IPseudoAtom;
+import org.openscience.cdk.renderer.selection.IChemObjectSelection;
+import org.openscience.cdk.renderer.selection.SingleSelection;
+import org.openscience.cdk.silent.SilentChemObjectBuilder;
+import org.openscience.cdk.tools.CDKHydrogenAdder;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
+
+import toxTree.exceptions.DecisionMethodException;
+import toxTree.query.MolFlags;
+import toxTree.tree.RuleResult;
+import toxTree.ui.tree.categories.CategoriesRenderer;
+import ambit2.core.data.MoleculeTools;
+import ambit2.core.processors.structure.HydrogenAdderProcessor;
+import ambit2.rendering.CompoundImageTools;
+import dk.smartcyp.core.MoleculeKU;
+import dk.smartcyp.core.MoleculeKU.SMARTCYP_PROPERTY;
+import dk.smartcyp.core.SMARTSData;
+import dk.smartcyp.core.SMARTSnEnergiesTable;
+
+public class SMARTCYPRuleRank1 extends MetaboliteGenerator {
+	protected static final CategoriesRenderer categoriesRenderer = new CategoriesRenderer(
+			4, 240);
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = -8348454708993409448L;
+
+	protected transient CDKHydrogenAdder adder = CDKHydrogenAdder
+			.getInstance(SilentChemObjectBuilder.getInstance());
+
+	public SMARTCYPRuleRank1() {
+		this(1);
+	}
+
+	public SMARTCYPRuleRank1(int rank) {
+		super();
+		setRank(rank);
+		setID(String.format("%d", rank));
+		setTitle(bundle.getString("title"));
+		setExplanation(String.format("Rank%d", rank));
+		setEditable(false);
+		setExamples(new String[] { "O", "C1C=CNC=C1" });
+	}
+
+	/**
+	 * returns true if at least one atom has a score assigned
+	 */
+	public boolean verifyRule(IAtomContainer mol)
+			throws DecisionMethodException {
+		try {
+
+			IAtomContainer newmol = mol;
+
+			boolean calculated = false;
+			for (IAtom atom : mol.atoms())
+				if (atom instanceof IPseudoAtom)
+					throw new DecisionMethodException(String.format(
+							"IPseudoAtoms are not supported! %s",
+							atom.getSymbol()));
+				else if (SMARTCYP_PROPERTY.Accessibility.getNumber(atom) != null) {
+					calculated = true;
+					break;
+				} else {
+					// System.out.print(atom.getProperties());
+				}
+			if (!calculated) {
+				AtomContainerManipulator.removeHydrogens(mol);
+				newmol = calculate(mol);
+			}
+			MolFlags mf = (MolFlags) mol.getProperty(MolFlags.MOLFLAGS);
+			IAtomContainerSet set = SilentChemObjectBuilder.getInstance()
+					.newInstance(IAtomContainerSet.class);
+			set.addAtomContainer(newmol);
+			mf.setResidues(set);
+
+			for (IAtom atom : newmol.atoms()) {
+				Number atom_rank = SMARTCYP_PROPERTY.Ranking.getNumber(atom);
+				SMARTSData data = SMARTCYP_PROPERTY.Energy.getData(atom);
+				if ((atom_rank != null) && hasRank(atom_rank.intValue())
+						&& (data != null))
+					return true;
+			}
+			return false;
+		} catch (DecisionMethodException x) {
+			throw x;
+		} catch (Exception x) {
+			throw new DecisionMethodException(x);
+		}
+	}
+
+	protected boolean hasRank(int atom_rank) {
+		return atom_rank == getRank();
+	}
+
+	public MoleculeKU calculate(IAtomContainer iAtomContainerTmp)
+			throws DecisionMethodException {
+		try {
+
+			IAtomContainer iAtomContainer = AtomContainerManipulator
+					.removeHydrogens(iAtomContainerTmp);
+			AtomContainerManipulator
+					.percieveAtomTypesAndConfigureAtoms(iAtomContainer);
+			if (adder == null)
+				adder = CDKHydrogenAdder.getInstance(SilentChemObjectBuilder
+						.getInstance());
+			CDKHueckelAromaticityDetector.detectAromaticity(iAtomContainer);
+			adder.addImplicitHydrogens(iAtomContainer);
+
+			MoleculeKU moleculeKU = new MoleculeKU(iAtomContainer,
+					SMARTSnEnergiesTable.getSMARTSnEnergiesTable());
+			// MoleculeKU moleculeKU = new MoleculeKU(iAtomContainerTmp,
+			// SMARTSnEnergiesTable.getSMARTSnEnergiesTable());
+			logger.finer("************** Matching SMARTS to assign Energies **************");
+			moleculeKU.assignAtomEnergies(SMARTSnEnergiesTable
+					.getSMARTSnEnergiesTable());
+
+			logger.finer("************** Calculating Accessabilities and Atom Scores**************");
+			moleculeKU.calculateAtomAccessabilities();
+
+			logger.finer("************** Identifying, sorting and ranking C, N, P and S atoms **************");
+			moleculeKU.sortAtoms();
+			moleculeKU.rankAtoms();
+
+			/*
+			 * for (IAtom matchingAtom: moleculeKU.atoms()) if
+			 * (SMARTCYP_PROPERTY.Energy.getData(matchingAtom)!=null) if
+			 * (SMARTCYP_PROPERTY.Ranking.getNumber(matchingAtom).intValue()==1)
+			 * System
+			 * .out.println(String.format("[%s] Rank %d >>%s [%s]",matchingAtom
+			 * .getID(), SMARTCYP_PROPERTY.Ranking.getNumber(matchingAtom),
+			 * SMARTCYP_PROPERTY.Energy.getData(matchingAtom).getEnergy(),
+			 * SMARTCYP_PROPERTY.Energy.getData(matchingAtom).getReaction()));
+			 */
+			return moleculeKU;
+		} catch (Exception x) {
+			throw new DecisionMethodException(x);
+		}
+	}
+
+	@Override
+	public IProcessor<IAtomContainer, IChemObjectSelection> getSelector() {
+		return new IProcessor<IAtomContainer, IChemObjectSelection>() {
+			/**
+		     * 
+		     */
+		    private static final long serialVersionUID = -2848526389291041910L;
+
+			public IChemObjectSelection process(IAtomContainer mol)
+					throws AmbitException {
+				try {
+					IAtomContainer selected = MoleculeTools
+							.newAtomContainer(SilentChemObjectBuilder
+									.getInstance());
+					verifyRule(mol, selected);
+					return new SingleSelection<IAtomContainer>(selected);
+				} 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 {
+			}
+
+		};
+	}
+
+	public boolean verifyRule(
+			org.openscience.cdk.interfaces.IAtomContainer mol,
+			IAtomContainer selected) throws DecisionMethodException {
+		try {
+			IAtomContainer newmol = mol;
+			for (IAtom atom : mol.atoms())
+				if (SMARTCYP_PROPERTY.Accessibility.getNumber(atom) == null) {
+					AtomContainerManipulator.removeHydrogens(mol);
+					newmol = calculate(mol);
+					break;
+				}
+			final double[] size = new double[] { 1.66, 1.33, 1.0, 0.5 };
+			for (int i = 0; i < newmol.getAtomCount(); i++) {
+				IAtom atom = newmol.getAtom(i);
+				Number atom_rank = SMARTCYP_PROPERTY.Ranking.getNumber(atom);
+				if ((atom_rank != null) && hasRank(atom_rank.intValue())) {
+					if (atom_rank.intValue() < 4) {
+						atom.setProperty(CompoundImageTools.SELECTED_ATOM_SIZE,
+								size[getRank() - 1]);
+						atom.setProperty(
+								CompoundImageTools.SELECTED_ATOM_COLOR,
+								categoriesRenderer.getShowColor(getRank() - 1));
+						selected.addAtom(atom);
+					}
+				}
+			}
+			return selected.getAtomCount() > 0;
+		} catch (Exception x) {
+			throw new DecisionMethodException(x);
+		}
+	}
+
+	@Override
+	public boolean isImplemented() {
+		return true;
+	}
+
+	@Override
+	public IAtomContainerSet getProducts(IAtomContainer reactant,
+			RuleResult ruleResult) throws Exception {
+		MoleculeKU mol = (reactant instanceof MoleculeKU) ? (MoleculeKU) reactant
+				: calculate(reactant);
+		// This is a workaround. CDK smarts matching needs implicit hydrogens,
+		// while ambit smarts/smirks matching needs explicit hydrogens...
+		HydrogenAdderProcessor.convertImplicitToExplicitHydrogens(mol);
+		return super.getProducts(mol, ruleResult);
+	}
+
+	@Override
+	public String getHelp(RuleResult ruleresult) {
+		return super.getHelp(ruleresult);
+	}
+}