Menu
▾
▴
[Cdk-commits] SF.net SVN: cdk: [9389] branches/miguelrojasch/mf/src/org/openscience/cdk
|
From: <mig...@us...> - 2007-11-07 07:57:02
|
Revision: 9389
http://cdk.svn.sourceforge.net/cdk/?rev=9389&view=rev
Author: miguelrojasch
Date: 2007-11-06 23:56:59 -0800 (Tue, 06 Nov 2007)
Log Message:
-----------
Different classes to handle molecular formula concept
Modified Paths:
--------------
branches/miguelrojasch/mf/src/org/openscience/cdk/DefaultChemObjectBuilder.java
branches/miguelrojasch/mf/src/org/openscience/cdk/MolecularFormula.java
branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugChemObjectBuilder.java
branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugMolecularFormula.java
branches/miguelrojasch/mf/src/org/openscience/cdk/interfaces/IChemObjectBuilder.java
branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NNMolecularFormula.java
branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NoNotificationChemObjectBuilder.java
branches/miguelrojasch/mf/src/org/openscience/cdk/test/MolecularFormulaTest.java
branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/IsotopeGeneratorTest.java
branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFAnalyser.java
branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java
Added Paths:
-----------
branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MFValidatorTest.java
branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFValidator.java
branches/miguelrojasch/mf/src/org/openscience/cdk/tools/manipulator/MolecularFormulaManipulator.java
branches/miguelrojasch/mf/src/org/openscience/cdk/tools/manipulator/MolecularFormulaSetManipulator.java
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/DefaultChemObjectBuilder.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/DefaultChemObjectBuilder.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/DefaultChemObjectBuilder.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -238,8 +238,8 @@
return new MolecularFormula();
}
- public IMolecularFormula newMolecularFormula(IAtomContainer container) {
- return new MolecularFormula(container);
+ public IMolecularFormula newMolecularFormula(IMolecularFormula molecularFormula) {
+ return new MolecularFormula(molecularFormula);
}
public IMonomer newMonomer () {
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/MolecularFormula.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/MolecularFormula.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/MolecularFormula.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -28,7 +28,6 @@
import java.util.Iterator;
import org.openscience.cdk.interfaces.IAtom;
-import org.openscience.cdk.interfaces.IAtomContainer;
import org.openscience.cdk.interfaces.IChemObjectChangeEvent;
import org.openscience.cdk.interfaces.IChemObjectListener;
import org.openscience.cdk.interfaces.IElement;
@@ -103,49 +102,42 @@
/**
- * Constructs an AtomContainer with a copy of the atoms and electronContainers
- * of another AtomContainer (A shallow copy, i.e., with the same objects as in
+ * Constructs an MolecularFormula with a copy MolecularFormula of another
+ * MolecularFormula (A shallow copy, i.e., with the same objects as in
* the original AtomContainer).
*
- * @param container An AtomContainer to copy the atoms and electronContainers from
+ * @param molecularFormula An MolecularFormula to copy from
*/
- public MolecularFormula(IAtomContainer container){
-
- this.atomCount = container.getAtomCount();
- this.elements = new IElement[this.elementCount];
-
+ public MolecularFormula(IMolecularFormula molecularFormula){
+
+ this.elements = new IElement[molecularFormula.getElementCount()];
elementRepetitions = new Hashtable<String, Integer>();
- Iterator<IAtom> iterator = container.atoms();
+ Iterator<IElement> iterator = molecularFormula.elements();
while(iterator.hasNext()){
- IAtom atom = (IAtom) iterator.next();
- IElement newElement = atom.getBuilder().newElement(atom.getSymbol());
- if (atom.getCharge() != null)
- charge =+ atom.getCharge();
- if (contains(newElement)){
- int repetitions = elementRepetitions.get(newElement.getSymbol());
- elementRepetitions.put(newElement.getSymbol(),new Integer(repetitions+1));
- }else{
- growElementArray(newElement);
- }
+ IElement element = (IElement) iterator.next();
+ int occu = molecularFormula.getAtomCount(element);
+ addElement(element,occu);
}
+ this.charge = molecularFormula.getCharge();
}
/**
* Adds a molecular formula to this MolecularFormula.
*
- *@param atomContainer The molecular formula to be added
+ *@param molecularFormula The molecular formula to be added
*/
- public void add(MolecularFormula molecularFormula){
+ public void add(IMolecularFormula molecularFormula){
- for (int f = 0; f < molecularFormula.getElementCount(); f++){
-
- if (!contains(molecularFormula.getElement(f))){
-
- addElement(molecularFormula.getElement(f));
- }
+ Iterator<IElement> iterator = molecularFormula.elements();
+ while(iterator.hasNext()){
+ IElement element = (IElement) iterator.next();
+ int occu = molecularFormula.getAtomCount(element);
+ addElement(element,occu);
}
+
+ this.charge += molecularFormula.getCharge();
notifyChanged();
}
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugChemObjectBuilder.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugChemObjectBuilder.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugChemObjectBuilder.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -264,8 +264,8 @@
return new DebugMolecularFormula();
}
- public IMolecularFormula newMolecularFormula(IAtomContainer container) {
- return new DebugMolecularFormula(container);
+ public IMolecularFormula newMolecularFormula(IMolecularFormula molecularFormula) {
+ return new DebugMolecularFormula(molecularFormula);
}
public IMonomer newMonomer () {
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugMolecularFormula.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugMolecularFormula.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/debug/DebugMolecularFormula.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -49,8 +49,8 @@
super();
}
- public DebugMolecularFormula(IAtomContainer container) {
- super(container);
+ public DebugMolecularFormula(IMolecularFormula molecularFormula) {
+ super(molecularFormula);
}
public void add(MolecularFormula molecularFormula) {
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/interfaces/IChemObjectBuilder.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/interfaces/IChemObjectBuilder.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/interfaces/IChemObjectBuilder.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -441,12 +441,12 @@
public IMolecularFormula newMolecularFormula();
/**
- * Creates an IMolecularFormula from an IAtomContainer.
+ * Creates an IMolecularFormula from an IMolecularFormula.
*
- * @param container An IMolecule to copy the atoms and bonds from
+ * @param molecularFormula An IMolecularFormula to copy from
* @return IMolecularFormula implementation defined for this IChemObjectBuilder
*/
- public IMolecularFormula newMolecularFormula(IAtomContainer container);
+ public IMolecularFormula newMolecularFormula(IMolecularFormula molecularFormula);
/**
* Constructs a new IMonomer.
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NNMolecularFormula.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NNMolecularFormula.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NNMolecularFormula.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -24,9 +24,9 @@
package org.openscience.cdk.nonotify;
import org.openscience.cdk.MolecularFormula;
-import org.openscience.cdk.interfaces.IAtomContainer;
import org.openscience.cdk.interfaces.IChemObjectBuilder;
import org.openscience.cdk.interfaces.IChemObjectListener;
+import org.openscience.cdk.interfaces.IMolecularFormula;
/**
* @author rojasm
@@ -41,8 +41,8 @@
super.setNotification(false);
}
- public NNMolecularFormula(IAtomContainer container) {
- super(container);
+ public NNMolecularFormula(IMolecularFormula molecularFormula) {
+ super(molecularFormula);
super.setNotification(false);
}
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NoNotificationChemObjectBuilder.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NoNotificationChemObjectBuilder.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/nonotify/NoNotificationChemObjectBuilder.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -270,8 +270,8 @@
return new NNMolecularFormula();
}
- public IMolecularFormula newMolecularFormula(IAtomContainer container) {
- return new NNMolecularFormula(container);
+ public IMolecularFormula newMolecularFormula(IMolecularFormula molecularFormula) {
+ return new NNMolecularFormula(molecularFormula);
}
public IMonomer newMonomer () {
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/test/MolecularFormulaTest.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/test/MolecularFormulaTest.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/test/MolecularFormulaTest.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -80,7 +80,7 @@
*
* @return The test suite
*/
- public void testSet1() {
+ public void testMolecularFormula_count() {
IMolecularFormula mf = builder.newMolecularFormula();
mf.addElement( builder.newElement("C") );
@@ -97,7 +97,7 @@
*
* @return The test suite
*/
- public void testSet2() {
+ public void testMolecularFormula_AtomsCount() {
IMolecularFormula mf = builder.newMolecularFormula();
IElement carb = builder.newElement("C");
IElement flu = builder.newElement("F");
@@ -124,7 +124,7 @@
*
* @return The test suite
*/
- public void testSet2_1() {
+ public void testMolecularFormula_AtomsCount2() {
IMolecularFormula mf = builder.newMolecularFormula();
IElement carb = builder.newElement("C");
IElement flu = builder.newElement("F");
@@ -141,33 +141,12 @@
assertEquals(1, mf.getAtomCount(mf.getFirstElement()));
assertEquals(3, mf.getAtomCount(mf.getLastElement()));
}
+
/**
* A unit test suite for JUnit
*
* @return The test suite
*/
- public void testSet2_2() {
- IMolecularFormula mf = builder.newMolecularFormula();
- IElement carb = builder.newElement("C");
- IElement flu = builder.newElement("F");
- IElement h1 = builder.newElement("H");
- mf.addElement( carb );
- mf.addElement( flu );
- mf.addElement( h1 ,3);
-
- assertEquals(3, mf.getElementCount());
- assertEquals(5, mf.getAtomCount());
- assertEquals(1, mf.getAtomCount(carb));
- assertEquals(1, mf.getAtomCount(flu));
- assertEquals(3, mf.getAtomCount(h1));
- assertEquals(1, mf.getAtomCount(mf.getFirstElement()));
- assertEquals(3, mf.getAtomCount(mf.getLastElement()));
- }
- /**
- * A unit test suite for JUnit
- *
- * @return The test suite
- */
public void testSet3() {
IMolecule acetone = builder.newMolecule();
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/IsotopeGeneratorTest.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/IsotopeGeneratorTest.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/IsotopeGeneratorTest.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -23,21 +23,19 @@
*/
package org.openscience.cdk.test.tools;
-import java.util.Iterator;
-
import junit.framework.Test;
import junit.framework.TestSuite;
import org.openscience.cdk.Atom;
import org.openscience.cdk.AtomContainer;
import org.openscience.cdk.Bond;
-import org.openscience.cdk.Isotope;
import org.openscience.cdk.exception.CDKException;
import org.openscience.cdk.interfaces.IAtom;
import org.openscience.cdk.interfaces.IAtomContainer;
import org.openscience.cdk.interfaces.IAtomContainerSet;
import org.openscience.cdk.test.CDKTestCase;
import org.openscience.cdk.tools.IsotopeGenerator;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
/**
* @cdk.module test-extra
@@ -76,6 +74,53 @@
*
* @return Description of the Return Value
*/
+ public void testCalculateIsotopesAllBromine() throws CDKException {
+ IAtomContainer m = new AtomContainer();
+ Atom b1 = new Atom("Br");
+ Atom b2 = new Atom("Br");
+ m.addAtom(b1);
+ m.addAtom(b2);
+ m.addBond(new Bond(b1, b2));
+
+ IsotopeGenerator isotopeGe = new IsotopeGenerator(0.01);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeGe.getAllIsotopes(m);
+
+ assertEquals(4, containerSet.getAtomContainerCount());
+
+ double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+ assertEquals(157.8366742, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+ assertEquals(159.8346277, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(2));
+ assertEquals(159.8346277, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(3));
+ assertEquals(161.8325812, mm, 0.0000001);
+
+
+ double sum = 0.0;
+ double ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(0));
+ sum += ab;
+ assertEquals(0.25694761, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(1));
+ sum += ab;
+ assertEquals(0.24995239, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(2));
+ sum += ab;
+ assertEquals(0.24995239, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(3));
+ sum += ab;
+ assertEquals(0.24314761, ab, 0.0000001);
+
+
+ assertEquals(1.0, sum, 0.0000001);
+
+ }
+
+ /**
+ * A unit test for JUnit: Isotopes of the Bromine.
+ *
+ * @return Description of the Return Value
+ */
public void testCalculateIsotopesBromine() throws CDKException {
IAtomContainer m = new AtomContainer();
Atom b1 = new Atom("Br");
@@ -83,43 +128,138 @@
m.addAtom(b1);
m.addAtom(b2);
m.addBond(new Bond(b1, b2));
+
+ IsotopeGenerator isotopeGe = new IsotopeGenerator(0.01);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeGe.getIsotopes(m);
- IAtomContainerSet containerSet = (IAtomContainerSet)isotopeG.getIsotopes(m);
+ assertEquals(3, containerSet.getAtomContainerCount());
- assertEquals(4, containerSet.getAtomContainerCount());
+ double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+ assertEquals(157.8366742, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+ assertEquals(159.8346277, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(2));
+ assertEquals(161.8325812, mm, 0.0000001);
- double mm = Math.round((getMass(containerSet.getAtomContainer(0))));
- assertEquals(158.0, mm, 0.0);
- mm = Math.round((getMass(containerSet.getAtomContainer(1))));
- assertEquals(160.0, mm, 0.0);
- mm = Math.round((getMass(containerSet.getAtomContainer(2))));
- assertEquals(160.0, mm, 0.0);
- mm = Math.round((getMass(containerSet.getAtomContainer(3))));
- assertEquals(162.0, mm, 0.0);
+ double sum = 0.0;
+ double ab = ((Double)containerSet.getAtomContainer(0).getProperty("abundanceTotal")).doubleValue();
+ sum += ab;
+ assertEquals(0.25694761, ab, 0.0000001);
+ ab = ((Double)containerSet.getAtomContainer(1).getProperty("abundanceTotal")).doubleValue();
+ sum += ab;
+ assertEquals(0.4999047, ab, 0.0000001);
+ ab = ((Double)containerSet.getAtomContainer(2).getProperty("abundanceTotal")).doubleValue();
+ sum += ab;
+ assertEquals(0.24314761, ab, 0.0000001);
+
+ assertEquals(1.0, sum, 0.0000001);
}
/**
- * A unit test for JUnit: Isotopes of the Chloromethylidyne.
+ * A unit test for JUnit: Isotopes of the Iodemethylidyne.
*
* @return Description of the Return Value
*/
- public void testCalculateIsotopesChloromethylidyne() throws CDKException {
+ public void testCalculateIsotopesIodemethylidyne() throws CDKException {
IAtomContainer m = new AtomContainer();
- Atom b1 = new Atom("C");
- Atom b2 = new Atom("Cl");
+ IAtom b1 = new Atom("C");
+ IAtom b2 = new Atom("I");
m.addAtom(b1);
m.addAtom(b2);
m.addBond(new Bond(b1, b2));
+ IsotopeGenerator isotopeGe = new IsotopeGenerator(0.0000001);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeGe.getAllIsotopes(m);
- IAtomContainerSet containerSet = (IAtomContainerSet)isotopeG.getIsotopes(m);
-
assertEquals(2, containerSet.getAtomContainerCount());
- double mm = Math.round((getMass(containerSet.getAtomContainer(0))));
- assertEquals(47.0, mm, 0.0);
- mm = Math.round((getMass(containerSet.getAtomContainer(1))));
- assertEquals(49.0, mm, 0.0);
+ double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+ assertEquals(138.904473, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+ assertEquals(139.9078278399, mm, 0.0000001);
+
+
+ double sum = 0.0;
+ double ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(0));
+ sum += ab;
+ assertEquals(0.9893, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(1));
+ sum += ab;
+ assertEquals(0.01070, ab, 0.0000001);
+
+
+ assertEquals(1.0, sum, 0.0000001);
+
}
+
+
/**
+ * A unit test for JUnit: Isotopes of the DiBromomethylidyne.
+ *
+ * @return Description of the Return Value
+ */
+ public void testCalculateIsotopesDibromomethylidyne() throws CDKException {
+ IAtomContainer m = new AtomContainer();
+ IAtom b1 = new Atom("C");
+ IAtom b2 = new Atom("Br");
+ IAtom b3 = new Atom("Br");
+ m.addAtom(b1);
+ m.addAtom(b2);
+ m.addAtom(b3);
+ m.addBond(new Bond(b1, b2));
+ m.addBond(new Bond(b1, b3));
+ IsotopeGenerator isotopeGe = new IsotopeGenerator(0.01);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeGe.getAllIsotopes(m);
+
+
+ assertEquals(8, containerSet.getAtomContainerCount());
+
+ double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+ assertEquals(169.8366742, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+ assertEquals(171.8346277, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(2));
+ assertEquals(171.8346277, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(3));
+ assertEquals(173.8325812, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(4));
+ assertEquals(170.84002904, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(5));
+ assertEquals(172.837982539, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(6));
+ assertEquals(172.8379825, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(7));
+ assertEquals(174.8359360, mm, 0.0000001);
+
+
+ double sum = 0.0;
+ double ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(0));
+ sum += ab;
+ assertEquals(0.254198270, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(1));
+ sum += ab;
+ assertEquals(0.2472778994, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(2));
+ sum += ab;
+ assertEquals(0.247277899427, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(3));
+ sum += ab;
+ assertEquals(0.240545930573, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(4));
+ sum += ab;
+ assertEquals(0.0027493394270, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(5));
+ sum += ab;
+ assertEquals(0.00267449057, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(6));
+ sum += ab;
+ assertEquals(0.00267449057, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(7));
+ sum += ab;
+ assertEquals(0.002601679427, ab, 0.0000001);
+
+
+ assertEquals(1.0, sum, 0.0000001);
+ }
+ /**
* A unit test for JUnit: Isotopes of the Chloromethylidyne with a
* restriction for those istopes which their abundance is higher than 50%.
*
@@ -133,35 +273,148 @@
m.addAtom(b2);
m.addBond(new Bond(b1, b2));
- IsotopeGenerator isotopeG2 = new IsotopeGenerator(50.0);
- IAtomContainerSet containerSet = (IAtomContainerSet)isotopeG2.getIsotopes(m);
+ IsotopeGenerator isotopeG2 = new IsotopeGenerator(0.01);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeG2.getAllIsotopes(m);
- assertEquals(1, containerSet.getAtomContainerCount());
+ assertEquals(4, containerSet.getAtomContainerCount());
- double mm = Math.round((getMass(containerSet.getAtomContainer(0))));
- assertEquals(47.0, mm, 0.0);
+ double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+ assertEquals(46.96885268, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+ assertEquals(48.96590259, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(2));
+ assertEquals(47.97220752, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(3));
+ assertEquals(49.96925743, mm, 0.0000001);
+
+ double sum = 0.0;
+ double ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(0));
+ sum += ab;
+ assertEquals(0.74969154, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(1));
+ sum += ab;
+ assertEquals(0.23960846, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(2));
+ sum += ab;
+ assertEquals(0.00810846, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(3));
+ sum += ab;
+ assertEquals(0.00259154, ab, 0.0000001);
+
+ assertEquals(1.0, sum, 0.0000001);
}
+
+
/**
- * returns the exact mass for a given molecular formula, using mass already set
- * for each element.
- *
- * @param ac The IAtomContiner
- * @return The mass value
+ * A unit test for JUnit: Isotopes of the n-Carbone
+ *
+ * @return Description of the Return Value
*/
- private float getMass(IAtomContainer ac){
- float mass = 0;
- Isotope h = new Isotope(1, "H", 1.0, 1.0);
- Iterator it = ac.atoms();
- while(it.hasNext()){
- IAtom atom = (IAtom) it.next();
- mass += atom.getExactMass();
+ public void testCalculateIsotopesnCarbono() throws CDKException {
+ IAtomContainer m = new AtomContainer();
+ Atom b1 = new Atom("C");
+ Atom b2 = new Atom("C");
+ Atom b3 = new Atom("C");
+ Atom b4 = new Atom("C");
+ Atom b5 = new Atom("C");
+ Atom b6 = new Atom("C");
+ m.addAtom(b1);
+ m.addAtom(b2);
+ m.addAtom(b3);
+ m.addAtom(b4);
+ m.addAtom(b5);
+ m.addAtom(b6);
+ m.addBond(new Bond(b1, b2));
+ m.addBond(new Bond(b2, b3));
+ m.addBond(new Bond(b3, b4));
+ m.addBond(new Bond(b4, b5));
+ m.addBond(new Bond(b5, b6));
- mass += atom.getHydrogenCount() * h.exactMass;
- }
- return mass;
+ IsotopeGenerator isotopeG2 = new IsotopeGenerator(0.01);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeG2.getAllIsotopes(m);
+
+
+ assertEquals(64, containerSet.getAtomContainerCount());
+
+ double sum = 0.0;
+ double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+ assertEquals(72.0, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+ assertEquals(73.00335484, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(2));
+ assertEquals(73.00335484, mm, 0.0000001);
+ mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(3));
+ assertEquals(73.00335484, mm, 0.0000001);
+
+ sum = 0.0;
+ double ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(0));
+ sum += ab;
+ assertEquals(0.937493044919, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(1));
+ sum += ab;
+ assertEquals(0.0101396700, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(2));
+ sum += ab;
+ assertEquals(0.0101396700, ab, 0.0000001);
+ ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(3));
+ sum += ab;
+ assertEquals(0.0101396700, ab, 0.0000001);
+
+ /*it needs more containers*/
+// assertEquals(1.0, sum, 0.0000001);
+
}
+
+ /**
+ * A unit test for JUnit: Isotopes of the n-Carbone
+ *
+ * @return Description of the Return Value
+ */
+ public void testCalculateIsotopesOrthinine() throws CDKException {
+ IAtomContainer m = new AtomContainer();
+ for(int i = 0 ; i < 5 ; i++)
+ m.addAtom(new Atom("C"));
+ for(int i = 0 ; i < 13 ; i++)
+ m.addAtom(new Atom("H"));
+ for(int i = 0 ; i < 2 ; i++)
+ m.addAtom(new Atom("N"));
+ for(int i = 0 ; i < 2 ; i++)
+ m.addAtom(new Atom("O"));
-
+ IsotopeGenerator isotopeG2 = new IsotopeGenerator(0.01);
+ IAtomContainerSet containerSet = (IAtomContainerSet)isotopeG2.getIsotopes(m);
+
+
+// assertEquals(64, containerSet.getAtomContainerCount());
+//
+// double sum = 0.0;
+// double mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(0));
+// assertEquals(72.0, mm, 0.0000001);
+// mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(1));
+// assertEquals(73.00335484, mm, 0.0000001);
+// mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(2));
+// assertEquals(73.00335484, mm, 0.0000001);
+// mm = AtomContainerManipulator.getTotalExactMass(containerSet.getAtomContainer(3));
+// assertEquals(73.00335484, mm, 0.0000001);
+//
+// sum = 0.0;
+// double ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(0));
+// sum += ab;
+// assertEquals(0.937493044919, ab, 0.0000001);
+// ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(1));
+// sum += ab;
+// assertEquals(0.0101396700, ab, 0.0000001);
+// ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(2));
+// sum += ab;
+// assertEquals(0.0101396700, ab, 0.0000001);
+// ab = AtomContainerManipulator.getTotalNaturalAbundance(containerSet.getAtomContainer(3));
+// sum += ab;
+// assertEquals(0.0101396700, ab, 0.0000001);
+//
+// /*it needs more containers*/
+//// assertEquals(1.0, sum, 0.0000001);
+
+ }
}
Added: branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MFValidatorTest.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MFValidatorTest.java (rev 0)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MFValidatorTest.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -0,0 +1,235 @@
+/* $Revision: 8658 $ $Author: egonw $ $Date: 2007-08-03 15:20:28 +0200 (Fri, 03 Aug 2007) $
+ *
+ * Copyright (C) 2005-2007 Miguel Rojasch <mig...@us...>
+ *
+ * Contact: cdk...@li...
+ *
+ * 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.
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+package org.openscience.cdk.test.tools;
+
+import java.util.ArrayList;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import org.openscience.cdk.DefaultChemObjectBuilder;
+import org.openscience.cdk.Element;
+import org.openscience.cdk.MolecularFormula;
+import org.openscience.cdk.interfaces.IElement;
+import org.openscience.cdk.interfaces.IMolecularFormula;
+import org.openscience.cdk.test.CDKTestCase;
+import org.openscience.cdk.tools.MFValidator;
+
+/**
+ * @cdk.module test-experimental
+ */
+public class MFValidatorTest extends CDKTestCase {
+
+ private DefaultChemObjectBuilder builder;
+
+ /**
+ * Constructor for the MFValidatorTest object
+ *
+ *@param name Description of the Parameter
+ */
+ public MFValidatorTest(String name){
+
+ super(name);
+ }
+
+ /**
+ * The JUnit setup method
+ */
+ public void setUp() throws Exception {
+ builder = DefaultChemObjectBuilder.getInstance();
+ }
+
+ /**
+ * A unit test suite for JUnit
+ *
+ * @return The test suite
+ */
+ public static Test suite() {
+
+ TestSuite suite = new TestSuite(MFValidatorTest.class);
+ return suite;
+ }
+
+ /**
+ * A unit test suite for JUnit
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Notnull(){
+
+ assertNotNull(new MFValidator());
+ }
+ /**
+ * A unit test suite for JUnit
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_NOT_ELEMENTS(){
+
+ IMolecularFormula mf = builder.newMolecularFormula();
+ assertNull((new MFValidator()).isValid(mf));
+ }
+ /**
+ * A unit test suite for JUnit.
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule1_NOTVALID(){
+ MolecularFormula mf = new MolecularFormula();
+ IElement carb = new Element("C");
+ IElement h1 = new Element("H");
+ mf.addElement( carb );
+ mf.addElement( h1 ,100);
+
+ assertEquals(MFValidator.NO_VALID_1,new MFValidator().isValid(mf));
+
+ assertFalse(new MFValidator().isValidRule_1(mf));
+ }
+
+ /**
+ * A unit test suite for JUnit.
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule1_remove_set(){
+
+ MFValidator mf = new MFValidator();
+ mf.removeRule_1();
+ assertEquals(false,mf.isAppliedRule_1());
+
+ mf.addRule_1();
+ assertEquals(true,mf.isAppliedRule_1());
+ }
+
+ /**
+ * A unit test suite for JUnit.
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule1_VALID(){
+ MolecularFormula mf = new MolecularFormula();
+ IElement carb = new Element("C");
+ IElement h1 = new Element("H");
+ mf.addElement( carb,2);
+ mf.addElement( h1 ,8);
+
+ assertEquals(MFValidator.VALID,new MFValidator().isValid(mf));
+
+ assertEquals(true,new MFValidator().isValidRule_1(mf));
+ }
+
+ /**
+ * A unit test suite for JUnit. Ratio C/H
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule2_Ratio_Novalid(){
+
+ MolecularFormula mf = new MolecularFormula();
+ IElement carbone = new Element("C");
+ mf.addElement( carbone );
+ IElement hydrogen = new Element("H");
+ mf.addElement( hydrogen, 10 );
+
+ MFValidator mfV = new MFValidator();
+
+ mfV.addRule_2();
+ assertEquals(MFValidator.NO_VALID_2,mfV.isValid(mf));
+ }
+
+
+ /**
+ * A unit test suite for JUnit.
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule3_dafault(){
+
+ MFValidator mf = new MFValidator();
+
+ assertEquals(false,mf.isAppliedRule_3());
+ assertEquals(0.1,mf.getAccuracyAbundance());
+ assertEquals(0.01,mf.getAccuracyMass());
+
+
+ }
+
+ /**
+ * A unit test suite for JUnit. Bromine
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule3_Bromine(){
+
+ MolecularFormula mf1 = new MolecularFormula();
+ IElement bromine = new Element("Br");
+ mf1.addElement( bromine,2 );
+
+ MolecularFormula mf2 = new MolecularFormula();
+ IElement carb = new Element("CC");
+ mf2.addElement( carb,2 );
+
+ MFValidator mfV = new MFValidator();
+
+ /** experimental results*/
+
+ ArrayList<double[]> spectrum = new ArrayList<double[]>();
+ spectrum.add(new double[]{157.8367,51.399});
+ spectrum.add(new double[]{159.8346,100.00});
+ spectrum.add(new double[]{161.8326,48.639});
+
+ mfV.addRule_3(spectrum);
+ assertEquals(MFValidator.VALID,mfV.isValid(mf1));
+
+ assertEquals(MFValidator.NO_VALID_3,mfV.isValid(mf2));
+ }
+
+ /**
+ * A unit test suite for JUnit. Bromine
+ *
+ * @return The test suite
+ */
+ public void testMFValidator_Rule3_Orthinine(){
+
+ MolecularFormula mf1 = new MolecularFormula();
+ IElement carb = new Element("C");
+ mf1.addElement( carb,5 );
+ IElement hyd = new Element("H");
+ mf1.addElement( hyd,13 );
+ IElement nit = new Element("N");
+ mf1.addElement( nit,2 );
+ IElement ox = new Element("O");
+ mf1.addElement( ox,2 );
+
+ MFValidator mfV = new MFValidator();
+
+ /** experimental results*/
+
+ ArrayList<double[]> spectrum = new ArrayList<double[]>();
+ spectrum.add(new double[]{133.0964,100.00});
+ spectrum.add(new double[]{133.0991,16.75});
+
+ mfV.addRule_3(spectrum);
+ assertEquals(MFValidator.VALID,mfV.isValid(mf1));
+
+ }
+}
+
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFAnalyser.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFAnalyser.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFAnalyser.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -58,7 +58,8 @@
private final static String H_ELEMENT_SYMBOL = "H";
- private String MF;
+ private String stringMF;
+ private IMolecularFormula molecularFormula;
private IAtomContainer atomContainer;
private int HCount = 0;
private boolean useboth=false;
@@ -73,10 +74,22 @@
* @param MF Description of the Parameter
* @param target TODO
*/
- public MFAnalyser(String MF, IAtomContainer target) {
- this.MF = MF;
+ public MFAnalyser(IMolecularFormula molecularFormula, IAtomContainer target) {
+ this.moleclarFormula = molecularFormula;
this.atomContainer = analyseMF(MF, target);
}
+ /**
+ * Construct an instance of MFAnalyser, initialized with a molecular
+ * formula string. The string is immediatly analysed and a set of Nodes
+ * is built based on this analysis
+ *
+ * @param MF Description of the Parameter
+ * @param target TODO
+ */
+ public MFAnalyser(String stringMF, IAtomContainer target) {
+ this.stringMF = stringMF;
+ this.atomContainer = analyseMF(MF, target);
+ }
/**
Added: branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFValidator.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFValidator.java (rev 0)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MFValidator.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -0,0 +1,438 @@
+/* $Revision: 9165 $ $Author: rajarshi $ $Date: 2007-10-22 01:11:04 +0200 (Mon, 22 Oct 2007) $
+ *
+ * Copyright (C) 2005-2007 Miguel Rojasch <mig...@us...>
+ *
+ * Contact: cdk...@li...
+ *
+ * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+package org.openscience.cdk.tools;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Hashtable;
+import java.util.Iterator;
+
+import org.openscience.cdk.ChemObject;
+import org.openscience.cdk.config.IsotopeFactory;
+import org.openscience.cdk.interfaces.IAtomContainer;
+import org.openscience.cdk.interfaces.IAtomContainerSet;
+import org.openscience.cdk.interfaces.IElement;
+import org.openscience.cdk.interfaces.IMolecularFormula;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
+
+/**
+ * <p> Validate a molecular formula given in IMolecularformula object. The
+ * validation is based according the paper of Tobias Kind on Seven
+ * Golden Rules for heuristic filetering of molecular formula (see kind2007).
+ * <p> As default are applied the first rule.
+ *
+ * @author Miguel Rojas
+ *
+ * @cdk.module standard
+ * @cdk.keyword molecule, molecular formula
+ */
+public class MFValidator {
+
+ private LoggingTool logger = new LoggingTool(MFValidator.class);
+
+ /** Applying rule 1. As default true */
+ private boolean applyRule_1 = true;
+
+ /** Applying rule 2. As default false */
+ private boolean applyRule_2 = true;
+
+ /** Applying rule 3. As default false */
+ private boolean applyRule_3 = false;
+
+ /** A enumeration of the possible results
+ * according the rules */
+ public enum Results {
+ VALID,
+ NO_VALID_1,
+ NO_VALID_2,
+ NO_VALID_3
+ }
+
+ /** A enumeration of the Rules*/
+ public enum Rules {
+ ONE,
+ SECOND,
+ THIRTH
+ }
+ /**
+ * Internal list of element maximum.
+ */
+ protected Hashtable<String, Integer> maxNrElements;
+
+ /**
+ * Internal list of element ratios.
+ */
+ protected Hashtable<String, Double> ratiosElementsC;
+
+ /** Accuracy on the abundance measuring isotope pattern*/
+ private double accuracyAbundance = 0.1;
+ /** Accuracy on the mass measuring isotope pattern*/
+ private double accuracyMass = 0.01;
+
+ /** Representation of a spectrum */
+ private ArrayList<double[]> spectrum;
+
+
+ IsotopeGenerator isotopeGe = new IsotopeGenerator(0.01);
+
+ /**The minimum score function accuracy to look for comparing isotope patterns.
+ * As default 0.9 */
+ private double minScore = 0.9;
+ /**
+ * Construct an instance of MFValidar. It is initialized already
+ * with the rules to applied. As default only rules 1 and 2.
+ */
+ public MFValidator() {
+ generateDefaultMaxNrElements();
+ generateDefaultRatiosElementsCH();
+
+ }
+
+ /**
+ * Validate if a molecular formula is valid.
+ * <p> -1, if not has elements
+ * <p> 0, if is valid
+ * <p> 1, if is not valid according rule 1
+ *
+ *
+ * @param mf The IMolecularFormula value
+ * @return If it is valid
+ */
+ public Results isValid(IMolecularFormula mf){
+ logger = new LoggingTool(this);
+
+ logger.info("Generating the validity of the molecular formula");
+
+ if(mf.getElementCount() == 0.0){
+ logger.error("Proposed molecular formula has not elements");
+ return null;
+ }
+
+ if(applyRule_1){
+ if(!isValidRule_1(mf))
+ return Results.NO_VALID_1;
+ }
+ if(applyRule_2){
+ if(!isValidRule_2(mf))
+ return Results.NO_VALID_2;
+ }
+ if(applyRule_3){
+ if(!isValidRule_3(mf))
+ return Results.NO_VALID_3;
+ }
+
+ return Results.VALID;
+ }
+
+ /**
+ * Validate the rule 1. It is based on Wiley mass spectral databases.
+ *
+ * @param mf The IMolecularFormula object
+ * @return TRUE, if the molecular formula pass the rule 1
+ */
+ public boolean isValidRule_1(IMolecularFormula mf) {
+ boolean valid = true;
+ this.applyRule_1 = true;
+
+ for(int i = 0 ; i < mf.getElementCount(); i++){
+ IElement element = mf.getElement(i);
+ Integer maxNr = this.maxNrElements.get(element.getSymbol());
+ if(maxNr != null){
+ if(maxNr.intValue() < mf.getAtomCount(element))
+ return false;
+ }
+ }
+ return valid;
+ }
+
+ /**
+ * add rule 1 to be applied. As default it is set already.
+ */
+ public void addRule_1(){
+ this.applyRule_1 = true;
+ if(maxNrElements == null)
+ generateDefaultMaxNrElements();
+ }
+
+ /**
+ * remove rule 1 to be applied. As default it is set already.
+ */
+ public void removeRule_1(){
+ this.applyRule_1 = false;
+ }
+
+
+ /**
+ * Get if the rule 1 is applied.
+ *
+ * @return TRUE, if the rule 1 is being applied
+ */
+ public boolean isAppliedRule_1(){
+ return applyRule_1;
+ }
+
+ /**
+ * Number of maximum elements proposed according the study. Necessary for rule 1.
+ */
+ private void generateDefaultMaxNrElements(){
+ this.maxNrElements = new Hashtable<String, Integer>();
+ this.maxNrElements.put("C", 39);
+ this.maxNrElements.put("H", 72);
+ this.maxNrElements.put("N", 20);
+ this.maxNrElements.put("O", 20);
+ this.maxNrElements.put("P", 9);
+ this.maxNrElements.put("S", 10);
+ this.maxNrElements.put("F", 16);
+ this.maxNrElements.put("Cl", 10);
+ this.maxNrElements.put("Br", 4);
+ this.maxNrElements.put("Si", 8);
+
+ }
+
+ /**
+ * Validate the rule 2. It is based on Wiley mass spectral databases.
+ *
+ * @param mf The IMolecularFormula object
+ * @return TRUE, if the molecular formula pass the rule 2
+ */
+ public boolean isValidRule_2(IMolecularFormula mf) {
+ boolean valid = true;
+ this.applyRule_2 = true;
+
+ IElement elementC = mf.getBuilder().newElement("C");
+ if(!mf.contains(elementC))
+ return valid;
+ else{
+ int nrCarb = mf.getAtomCount(elementC);
+ int pos = mf.getElementNumber(elementC);
+ for(int i = 0 ; i < mf.getElementCount(); i++)
+ if(i != pos){
+ IElement element = mf.getElement(i);
+ int nrElements = mf.getAtomCount(element);
+ Double maxRatio = ratiosElementsC.get(element.getSymbol());
+ double result = (nrElements/nrCarb);
+ if(maxRatio != null)
+ if(maxRatio.doubleValue() < result)
+ return false;
+
+ }
+ }
+
+ return valid;
+ }
+
+ /**
+ * add rule 2 to be applied. As default it is set already.
+ */
+ public void addRule_2(){
+ this.applyRule_2 = true;
+ if(ratiosElementsC == null)
+ generateDefaultRatiosElementsCH();
+ }
+
+ /**
+ * remove rule 2 to be applied. As default it is set already.
+ */
+ public void removeRule_2(){
+ this.applyRule_2 = false;
+ }
+
+
+ /**
+ * Get if the rule 2 is applied.
+ *
+ * @return TRUE, if the rule 2 is being applied
+ */
+ public boolean isAppliedRule_2(){
+ return applyRule_2;
+ }
+
+ /**
+ * Number of maximum elements proposed according the study. Necessary for rule 1.
+ */
+ private void generateDefaultRatiosElementsCH(){
+ ratiosElementsC = new Hashtable<String, Double>();
+ ratiosElementsC.put("H", 6.0);
+ ratiosElementsC.put("F", 1.5);
+ ratiosElementsC.put("Cl", 0.8);
+ ratiosElementsC.put("Br", 0.8);
+ ratiosElementsC.put("N", 1.3);
+ ratiosElementsC.put("O", 1.2);
+ ratiosElementsC.put("P", 0.3);
+ ratiosElementsC.put("S", 0.8);
+ ratiosElementsC.put("Si", 0.5 );
+ }
+ /**
+ * Validate the rule 3. It is based on Wiley mass spectral databases.
+ *
+ * @param mf The IMolecularFormula object
+ * @return TRUE, if the molecular formula pass the rule 2
+ */
+ public boolean isValidRule_3(IMolecularFormula mf) {
+ boolean valid = true;
+ this.applyRule_3 = true;
+
+ /*create a IAtomContainer*/
+ Iterator<IElement> iterator = mf.elements();
+ IAtomContainer atomContainer = mf.getBuilder().newAtomContainer();
+
+ while(iterator.hasNext()){
+ IElement element = iterator.next();
+ int rep = mf.getAtomCount(element);
+ for(int i = 0 ; i < rep; i++)
+ atomContainer.addAtom(mf.getBuilder().newAtom(element));
+ }
+ IMolecularFormulaSet containerSet = (IMolecularFormulaSet)isotopeGe.getIsotopesNormalized(atomContainer);
+
+
+ double thisScore = extractScore(containerSet);
+
+ if(thisScore < minScore)
+ return false;
+
+ return valid;
+ }
+
+
+ /**
+ * Extract a score function looking for similarities between isotopes pattern
+ *
+ * @param containerSet The IAtomContainerSet
+ * @return The score function value
+ */
+ private double extractScore(IAtomContainerSet containerSet) {
+ double score = 1.0;
+ for(int i = 0; i < spectrum.size(); i++){
+ boolean foundPeak = false;
+ double massS = spectrum.get(i)[0];
+ double abundS = spectrum.get(i)[1]/100;
+ Iterator<IAtomContainer> iteratorAC = containerSet.atomContainers();
+ while(iteratorAC.hasNext()){
+ IAtomContainer ac = iteratorAC.next();
+ double mass = AtomContainerManipulator.getTotalExactMass(ac);
+
+ if((mass-accuracyMass < massS)&(massS < mass+accuracyMass )){
+ double maxM = 0.0;
+ double minM = 0.0;
+ if(mass > massS){
+ maxM = mass;
+ minM = massS;
+ }else{
+ maxM = massS;
+ minM = mass;
+ }
+ score = score*( maxM / minM);
+ foundPeak = true;
+ }
+
+ }
+ if(!foundPeak)
+ score = score*(1-abundS);
+
+ }
+ return score;
+ }
+
+ /**
+ * add rule 3 to be applied. As default it is set already.
+ *
+ * @param spectrum Distribution of the isotope abundance
+ */
+ public void addRule_3(ArrayList<double[]> spectrum){
+ this.applyRule_3 = true;
+ this.spectrum = spectrum;
+ }
+
+ /**
+ * remove rule 3 to be applied. As default it is set already.
+ */
+ public void removeRule_3(){
+ this.applyRule_3 = false;
+ }
+
+ /**
+ * Get if the rule 3 is applied.
+ *
+ * @return TRUE, if the rule 2 is being applied
+ */
+ public boolean isAppliedRule_3(){
+ return applyRule_3;
+ }
+
+ /**
+ * Set minimum score function on the accuracy. As default 0.9
+ *
+ * @param minScore The minimum score function accuracy to look for
+ */
+ public void setScoreFunct(double minScore){
+ this.minScore = minScore;
+ }
+
+ /**
+ * Get minimum score function on accuracy.
+ *
+ * @return The minimum score function accuracy value
+ */
+ public double getScoreFunct(){
+ return this.minScore;
+ }
+ /**
+ * Set minimum isotope abundance measure accuracy.
+ *
+ * @param accuracy The minimum isotope abundance accuracy to look for
+ */
+ public void setAccuracyAbundance(double accuracy){
+ this.accuracyAbundance = accuracy;
+ }
+
+ /**
+ * Get minimum isotope abundance measure accuracy.
+ *
+ * @return The minimum isotope abundance accuracy value
+ */
+ public double getAccuracyAbundance(){
+ return this.accuracyAbundance;
+ }
+
+ /**
+ * Set minimum isotope mass measure accuracy.
+ *
+ * @param accuracy The minimum isotope mass accuracy to look for
+ */
+ public void setAccuracyMass(double accuracy){
+ this.accuracyMass = accuracy;
+ }
+
+ /**
+ * Get minimum isotope mass measure accuracy.
+ *
+ * @return The minimum isotope mass accuracy value
+ */
+ public double getAccuracyMass(){
+ return this.accuracyMass;
+ }
+}
+
+
Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java
===================================================================
--- branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java 2007-11-06 23:07:59 UTC (rev 9388)
+++ branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java 2007-11-07 07:56:59 UTC (rev 9389)
@@ -1,6 +1,6 @@
/* $Revision: 8397 $ $Author: rajarshi $ $Date: 2007-06-24 05:24:27 +0200 (Sun, 24 Jun 2007) $
*
- * Copyright (C) 1997 Guillaume Cottenceau <gco...@en...>
+ * Copyright (C) 2005-2007 Miguel Rojasch <mig...@us...>
*
* Contact: cdk...@li...
*
@@ -26,22 +26,38 @@
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
-
import org.openscience.cdk.ChemObject;
import org.openscience.cdk.DefaultChemObjectBuilder;
-import org.openscience.cdk.Molecule;
+import org.openscience.cdk.Element;
+import org.openscience.cdk.MolecularFormula;
import org.openscience.cdk.config.AtomTypeFactory;
import org.openscience.cdk.config.IsotopeFactory;
-import org.openscience.cdk.exception.NoSuchAtomTypeException;
-import org.openscience.cdk.interfaces.IAtomType;
+import org.openscience.cdk.interfaces.IAtom;
+import org.openscience.cdk.interfaces.IAtomContainer;
import org.openscience.cdk.interfaces.IChemObjectBuilder;
import org.openscience.cdk.interfaces.IElement;
import org.openscience.cdk.interfaces.IIsotope;
+import org.openscience.cdk.interfaces.IMolecularFormula;
+import org.openscience.cdk.tools.manipulator.AtomContainerManipulator;
/**
- * Tool to determine molecular formula consistent with a given accurate mass.
+ * <p>Tool to determine molecular formula consistent with a given accurate mass. The
+ * molecular formulas are not validate. It only consist in generate combination according
+ * object (see MolecularFormulaChecker).
*
+ * <pre>
+ * MassToFormulaTool mf = new MassToFormulaTool();
+ * double myMass = 133.004242;
+ * ArrayList<IMolecularFormula> resultsMF = mf.generate(myMass);
+ * </pre>
+ *
+ * <p>The elements are listed in order of probable occurrence, beginning the C, H, O then N and
+ * so on.
+ * <p>The elements are not listed according on difference with the proposed mass(see MFAnalyser).
+ *
* @author Miguel Rojas
*
* @cdk.module experimental
@@ -53,144 +69,254 @@
/** The mass which is calculate the molecular formula. */
private double mass;
-
- /** The max number of solutions to be found. Default number fixed to 50*/
- private static int max_Solutions = 50;
-
- /** The molecular formulas obtained from the accurate mass.*/
- private ArrayList<String> molecularFormula;
protected IChemObjectBuilder builder = DefaultChemObjectBuilder.getInstance();
- /** Elements that must be presents in the molecular formula.*/
- private IElement_Nr[] elemToCond;
+ /** Elements that must be presents in the molecular formula. As default they
+ * are O,N,C and H*/
+ private IElement_Nr[] elemToCond = generateElemDefault();
- /** Mass Ratio to look for. As default 0.05*/
- private static double ratio = 0.05;
+ /** Mass tolerance to look for. As default 0.05 amu*/
+ private double tolerance = 0.05;
+ /** */
AtomTypeFactory factory;
- /** charge of the compound. As default is 0 meaning neutral compound.**/
- private static int charge = 0;
+ /** charge of the compound. As default is 0, meaning neutral compound.**/
+ private double charge = 0;
+
+ /** matrix to follow for the permutations*/
+ private int[][] matrix_Base;
+
+ /** Array listing the order of the elements to be shown according probability occurrence*/
+ private String[] orderElements;
+
+
/**
* Construct an instance of MassToFormulaTool.
*/
public MassToFormulaTool() {
+
+ factory = AtomTypeFactory.getInstance(new ChemObject().getBuilder());
+ this.matrix_Base = callMatrix(elemToCond.length);
+ this.orderElements = generateOrderE();
+
}
/**
- * Construct an instance of MassToFormulaTool, initialized with a mass.
+ * Set the elements that must be presents in the molecular formula.
+ * They will be set as default number of occurrence for each element
+ * as minimum = 0 and maximum = 9.
*
- * @param mass Mass with which is determined the molecular formula
+ * @param elemToCon IElements that must be presents
+ * @see #setElements(org.openscience.cdk.tools.MassToFormulaTool.IElement_Nr[])
*/
- public MassToFormulaTool(double mass) {
- this(mass, max_Solutions, null);
+ public void setElements(IElement[] elem){
+ IElement_Nr[] elemToCondione_re = null;
+ /*convert the IElement array to IElement_Nr which contains as default(0,9) the number of maximum
+ * and minimum the repetitions for each IElement.*/
+ if((elem != null)&(elem.length > 0)){
+ elemToCond = new IElement_Nr[elem.length];
+ for(int i = 1; i < elemToCondione_re.length; i++)
+ elemToCond[i] = new IElement_Nr(elem[i].getSymbol(),0,9);
+
+
+ /*put in order descendant the Elements according their mass*/
+ this.elemToCond = ordningElements(elemToCond);
+
+ if(matrix_Base[1].length != elemToCond.length)
+ this.matrix_Base = callMatrix(elemToCond.length);
+ }else{
+ logger.error("The list IElement object is null or not contain elements");
+// return null;
+ }
+
}
-
/**
- * Construct an instance of MassToFormulaTool, initialized with a mass.
- * This constructor restricts the number maxim of elemental elements to be
- * found.
+ * Set the elements that must be presents in the molecular formula.
+ * The IElement_Nr object is subclass of IElement containing the occurrence max and min.
*
- * @param mass Mass with which is determined the molecular formula
- * @param max_Solut Number max of solutions
+ * @param elemToCon IElements_Nr
+ * @see #setElements(IElement[])
*/
- public MassToFormulaTool(double mass, int max_solut) {
- this(mass, max_solut, null);
+ public void setElements(IElement_Nr[] elemToCond){
+ if((elemToCond != null)&(elemToCond.length > 0)){
+ this.elemToCond = elemToCond;
+ this.matrix_Base = callMatrix(elemToCond.length);
+ }else
+ logger.error("The list IElement_Nr object is null or not contain elements");
+
+
+ /*put in order descendant the Elements according their mass*/
+ this.elemToCond = ordningElements(elemToCond);
}
-
/**
- * Construct an instance of MassToFormulaTool, initialized with a mass.
- * This constructor restricts the elements to be found.
+ * Set the charge of the molecule. As default is 0, meaning neutral compound.
*
- * @param mass Mass with which is determined the molecular formula
- * @param elemToCondione Elements that must be presents
+ * @param charge The charge value
*/
- public MassToFormulaTool(double mass, IElement[] elemToCondione) {
- this(mass, max_Solutions, elemToCondione);
+ public void setCharge(double charge){
+ this.charge = charge;
}
/**
- * Construct an instance of MassToFormulaTool, initialized with a mass.
- * This constructor restricts the elements to be found and the charge.
+ * Set the mass tolerance. As Default 0.05 uma.
*
- * @param mass Mass with which is determined the molecular formula
-// * @param charge Charge of the molecule
- * @param elemToCondione Elements that must be presents
+ * @param tolerance The mass tolerance value
*/
-// public MassToFormulaTool(double mass, int charge, IElement[] elemToCondione) {
-// this(mass, max_Solutions, charge, elemToCondione);
-// }
- /**
- * Construct an instance of MassToFormulaTool, initialized with a mass.
- * This constructor restricts the elements to be found and the charge.
- * This constructor restricts the number maxim of elemental elements to be
- * found.
- *
- * @param mass Mass with which is determined the molecular formula
- * @param max_Solut Number max of solutions to be found
-// * @param charge Charge of the molecule
- * @param elemToCondione Elements that must be presents
- */
- public MassToFormulaTool(double mass, int max_Solut, IElement[] elemToCondione) {
- IElement_Nr[] elemToCondione_re = null;
- /*convert the IElement array to IElement_Nr which contains as default(0,9) the number of maximum
- * and minimum the repetitions for each IElement.*/
- if(elemToCondione != null){
- elemToCondione_re = new IElement_Nr[elemToCondione.length];
- for(int i = 1; i < elemToCondione_re.length; i++)
- elemToCondione_re[i] = new IElement_Nr(elemToCondione[i].getSymbol(),0,9);
-
- }
-
- this.molecularFormula = analyseMF(mass, max_Solut, 0, ratio, elemToCondione_re);
+ public void setTolerance(double tolerance){
+ this.tolerance = tolerance;
}
/**
- * Construct an instance of MassToFormulaTool, initialized with a mass.
- * This constructor restricts the elements to be found and the charge.
- * This constructor restricts the number maxim of elemental elements to be
- * found.
- *
- * @param mass Mass with which is determined the molecular formula
- * @param max_Solut Number max of solutions to be found
- * @param charge Charge of the molecule
- * @param ratio Ratio between the mass of the molecular formula and the mass to apply
- * @param elemToCondione Elements that must be presents
- */
- public MassToFormulaTool(double mass, int max_Solut, int charge, double ratio, IElement_Nr[] elemToCondione) {
- this.molecularFormula = analyseMF(mass, max_Solut, charge, ratio, elemToCondione);
- }
-
- /**
* Method that actually does the work of extracting the molecular formula.
*
- * @param mass molecular formula to create an AtomContainer from
- * @param max_Solut Number max of solutions
- * @param charge Charge of the molecule
- * @param elemToCondione Elements that must be presents
- * @param ratio Ratio between the mass of the molecular formula and the mass to apply
+ * @param mass molecular formula to create from the mass
* @return the filled molecular formula as ArrayList
*/
- private ArrayList<String> analyseMF(double m, int max_Solut, int charg, double rat, IElement_Nr[] elemToCondione) {
+ public List<IMolecularFormula> generate(double mass) {
- ArrayList<String> solutions_found = new ArrayList<String>();
+ ArrayList<IMolecularFormula> solutions_found = new ArrayList<IMolecularFormula>();
- if(m == 0.0){
- logger.error("Proposed mass is not a valid: ",mass);
+ if(mass == 0.0){
+ logger.error("Proposed mass is not valid: ",mass);
return null;
}else
- mass = m;
+ this.mass = mass;
- factory = AtomTypeFactory.getInstance("org/openscience/cdk/config/data/valency_atomtypes.xml", new ChemObject().getBuilder());
- max_Solutions = max_Solut;
- ratio = rat;
- charge = charg;
- if(elemToCondione == null)
- elemToCond = generateElemDefault();
- else
- elemToCond = elemToCondione;
+ int[][] matrix = this.matrix_Base;
- /*put in order descendent the Elements according their mass*/
+ for(int i = 0; i < matrix.length ; i++){
+
+
+ /*constructing initial combinations*/
+ int[] value_In = new int[elemToCond.length];
+ for(int j= 0; j < elemToCond.length ; j++){
+ if(matrix[i][j] == 0)
+ value_I...
[truncated message content] |