From: <mig...@us...> - 2007-11-07 20:04:07
|
Revision: 9406 http://cdk.svn.sourceforge.net/cdk/?rev=9406&view=rev Author: miguelrojasch Date: 2007-11-07 12:04:02 -0800 (Wed, 07 Nov 2007) Log Message: ----------- added class Restriction into the method MassToFormulaTool. And tests. Modified Paths: -------------- branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MassToFormulaToolTest.java branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MassToFormulaToolTest.java =================================================================== --- branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MassToFormulaToolTest.java 2007-11-07 19:51:38 UTC (rev 9405) +++ branches/miguelrojasch/mf/src/org/openscience/cdk/test/tools/MassToFormulaToolTest.java 2007-11-07 20:04:02 UTC (rev 9406) @@ -20,20 +20,22 @@ */ 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.interfaces.IMolecularFormula; +import org.openscience.cdk.interfaces.IMolecularFormulaSet; import org.openscience.cdk.test.CDKTestCase; import org.openscience.cdk.tools.MassToFormulaTool; -import org.openscience.cdk.tools.MassToFormulaTool.IElement_Nr; +import org.openscience.cdk.tools.MassToFormulaTool.Restrictions; /** * @cdk.module test-experimental */ public class MassToFormulaToolTest extends CDKTestCase { + private DefaultChemObjectBuilder builder; /** * Constructor for the MassToFormulaToolTest object * @@ -48,6 +50,7 @@ * The JUnit setup method */ public void setUp() throws Exception { + builder = DefaultChemObjectBuilder.getInstance(); } /** @@ -63,102 +66,145 @@ public void testMassToFormulaTool() { - assertNotNull(new MassToFormulaTool(0.0)); + assertNotNull(new MassToFormulaTool()); } /** * A unit test suite for JUnit * * @return The test suite */ - public void testMassToFormulaTool_null(){ + public void testMass_0(){ - assertNull(new MassToFormulaTool(0.0).getMolecularFormula()); + assertEquals(0,new MassToFormulaTool().generate(0.0).getMolecularFormulaCount()); } /** * A unit test suite for JUnit * * @return The test suite */ - public void testMassToFormulaTool1(){ + public void testMass_Not_NULL(){ - assertNotNull(new MassToFormulaTool(44.0032).getMolecularFormula()); + assertNotNull(new MassToFormulaTool().generate(44.0032)); } + + + /** + * A unit test suite for JUnit + * + * @return The test suite + */ + public void testRestrictions_Default(){ + MassToFormulaTool mfTool = new MassToFormulaTool(); + + Restrictions restrictions = mfTool.getRestrictions(); + assertNotNull(restrictions); + + assertEquals(0.0, restrictions.getCharge(), 0.00001); + assertEquals(0.05, restrictions.getTolerance(), 0.00001); + assertEquals(4, restrictions.getElements().size()); + } + /** - * A unit test suite for JUnit. Results contrasted with the page: - * http://www.ch.ic.ac.uk/java/applets/f2m2f/ + * A unit test suite for JUnit * * @return The test suite */ - public void testMassToFormulaTool2(){ - String[] resultsFromPage = {"O2C1","O1N2","O1N1C1H2","O1C2H4","N3H2","N2C1H4","N1C2H6"}; - /*obtained only those possible molecular formula according graphical maps*/ - String[] resultsFromMy = {"O2C1","O1N2","O1C2H4","N2C1H4"}; - ArrayList<String> resultsMF = new MassToFormulaTool(44.0032).getMolecularFormula(); - for(int i = 0 ; i < resultsMF.size(); i++){ - assertEquals(resultsFromMy[i],(String)resultsMF.get(i)); - } + public void testRestrictions_Charge(){ + MassToFormulaTool mfTool = new MassToFormulaTool(); + + Restrictions restrictions = mfTool.getRestrictions(); + assertEquals(0.0, restrictions.getCharge(), 0.00001); + + restrictions = mfTool.new Restrictions(); + restrictions.setCharge(1.0); + mfTool.setRestrictions(restrictions); + assertEquals(1.0, restrictions.getCharge(), 0.00001); + } /** - * A unit test suite for JUnit. Restriction with the occurrences + * A unit test suite for JUnit * * @return The test suite */ - public void testMassToFormulaTool4(){ - String[] results = {"O2C1","O1N2","O1C2H4","N2C1H4"}; - IElement_Nr[] elem = new IElement_Nr[4]; - MassToFormulaTool mToF = (new MassToFormulaTool()); - elem[0] = mToF.new IElement_Nr("C",0,9); - elem[1] = mToF.new IElement_Nr("H",0,9); - elem[2] = mToF.new IElement_Nr("O",0,9); - elem[3] = mToF.new IElement_Nr("N",0,9); + public void testRestrictions_Tolerance(){ + MassToFormulaTool mfTool = new MassToFormulaTool(); - ArrayList<String> resultsMF = new MassToFormulaTool(44.0032, 50, 0, 0.05, elem).getMolecularFormula(); + Restrictions restrictions = mfTool.getRestrictions(); + assertEquals(0.05, restrictions.getTolerance(), 0.00001); - for(int i = 0 ; i < resultsMF.size(); i++){ - assertEquals(results[i],(String)resultsMF.get(i)); - } + restrictions = mfTool.new Restrictions(); + restrictions.setTolerance(0.005); + mfTool.setRestrictions(restrictions); + assertEquals(0.005, restrictions.getTolerance(), 0.00001); + } + /** - * A unit test suite for JUnit. Restriction with the occurrences + * A unit test suite for JUnit * * @return The test suite */ - public void testMassToFormulaTool5(){ - String[] results = {"O1C2H4","N2C1H4"}; - IElement_Nr[] elem = new IElement_Nr[4]; - MassToFormulaTool mToF = (new MassToFormulaTool()); - elem[0] = mToF.new IElement_Nr("C",1,4); - elem[1] = mToF.new IElement_Nr("H",0,6); - elem[2] = mToF.new IElement_Nr("O",0,0); - elem[3] = mToF.new IElement_Nr("N",0,1); + public void testRestrictions_Elements(){ + MassToFormulaTool mfTool = new MassToFormulaTool(); - ArrayList<String> resultsMF = new MassToFormulaTool(44.0032, 50, 0, 0.05, elem).getMolecularFormula(); + Restrictions restrictions = mfTool.getRestrictions(); + assertEquals(4, restrictions.getElements().size()); + assertEquals(0, restrictions.getElements().get(0).getOccurrenceMin()); + assertEquals(15, restrictions.getElements().get(0).getOccurrenceMax()); - for(int i = 0 ; i < resultsMF.size(); i++){ - assertEquals(results[i],(String)resultsMF.get(i)); - } + restrictions = mfTool.new Restrictions(); + + restrictions.addElement("C",4,8); + restrictions.addElement("H",4,8); + restrictions.addElement("O",4,8); + restrictions.addElement("N",4,8); + restrictions.addElement("P",4,8); + restrictions.addElement("S",4,8); + + mfTool.setRestrictions(restrictions); + assertEquals(6, restrictions.getElements().size()); + assertEquals(4, restrictions.getElements().get(0).getOccurrenceMin()); + assertEquals(8, restrictions.getElements().get(0).getOccurrenceMax()); + } /** - * A unit test suite for JUnit. Molecular formula with charge + * A unit test suite for JUnit. * * @return The test suite */ - public void testMassToFormulaTool6(){ - String[] resultsFromPage = {"C2HO","CHN2","C2H3N","C3H5","H9O2","H11NO"}; - String[] resultsFromMy = {"[O1C2H1]+1","[N2C1H1]+1","[C3H5]+1"}; - IElement_Nr[] elem = new IElement_Nr[4]; - MassToFormulaTool mToF = (new MassToFormulaTool()); - elem[0] = mToF.new IElement_Nr("C",0,9); - elem[1] = mToF.new IElement_Nr("H",0,9); - elem[2] = mToF.new IElement_Nr("O",0,9); - elem[3] = mToF.new IElement_Nr("N",0,9); + public void testValidation_Orthynine(){ + + IMolecularFormula mf1 = builder.newMolecularFormula(); + mf1.addElement(builder.newElement("C"), 3); + mf1.addElement(builder.newElement("H"), 11); + mf1.addElement(builder.newElement("O"), 1); + mf1.addElement(builder.newElement("N"), 5); - ArrayList<String> resultsMF = new MassToFormulaTool(41.0032, 50, 1, 0.05, elem).getMolecularFormula(); + + IMolecularFormula mf2 = builder.newMolecularFormula(); + mf2.addElement(builder.newElement("C"), 5); + mf2.addElement(builder.newElement("H"), 13); + mf2.addElement(builder.newElement("O"), 2); + mf2.addElement(builder.newElement("N"), 2); - for(int i = 0 ; i < resultsMF.size(); i++){ - assertEquals(resultsFromMy[i],(String)resultsMF.get(i)); - } + IMolecularFormulaSet mfSet = new MassToFormulaTool().generate(133.0968); + + assertEquals(mf1.getElementCount(), mfSet.getMolecularFormula(0).getElementCount()); + assertEquals(mf1.getAtomCount(), mfSet.getMolecularFormula(0).getAtomCount()); + assertEquals(mf1.getFirstElement().getSymbol(), mfSet.getMolecularFormula(0).getFirstElement().getSymbol()); + assertEquals(mf1.getLastElement().getSymbol(), mfSet.getMolecularFormula(0).getLastElement().getSymbol()); + assertEquals(mf1.getAtomCount(mf1.getFirstElement()), mfSet.getMolecularFormula(0).getAtomCount(mfSet.getMolecularFormula(0).getFirstElement())); + assertEquals(mf1.getAtomCount(mf1.getLastElement()), mfSet.getMolecularFormula(0).getAtomCount(mfSet.getMolecularFormula(0).getLastElement())); + + + assertEquals(mf2.getElementCount(), mfSet.getMolecularFormula(1).getElementCount()); + assertEquals(mf2.getAtomCount(), mfSet.getMolecularFormula(1).getAtomCount()); + assertEquals(mf2.getFirstElement().getSymbol(), mfSet.getMolecularFormula(1).getFirstElement().getSymbol()); + assertEquals(mf2.getLastElement().getSymbol(), mfSet.getMolecularFormula(1).getLastElement().getSymbol()); + assertEquals(mf2.getAtomCount(mf2.getFirstElement()), mfSet.getMolecularFormula(1).getAtomCount(mfSet.getMolecularFormula(1).getFirstElement())); + assertEquals(mf2.getAtomCount(mf2.getLastElement()), mfSet.getMolecularFormula(1).getAtomCount(mfSet.getMolecularFormula(1).getLastElement())); + } } Modified: branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java =================================================================== --- branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java 2007-11-07 19:51:38 UTC (rev 9405) +++ branches/miguelrojasch/mf/src/org/openscience/cdk/tools/MassToFormulaTool.java 2007-11-07 20:04:02 UTC (rev 9406) @@ -33,6 +33,7 @@ import org.openscience.cdk.DefaultChemObjectBuilder; import org.openscience.cdk.Element; import org.openscience.cdk.MolecularFormula; +import org.openscience.cdk.MolecularFormulaSet; import org.openscience.cdk.config.AtomTypeFactory; import org.openscience.cdk.config.IsotopeFactory; import org.openscience.cdk.interfaces.IAtom; @@ -41,6 +42,7 @@ import org.openscience.cdk.interfaces.IElement; import org.openscience.cdk.interfaces.IIsotope; import org.openscience.cdk.interfaces.IMolecularFormula; +import org.openscience.cdk.interfaces.IMolecularFormulaSet; import org.openscience.cdk.tools.manipulator.AtomContainerManipulator; /** @@ -51,14 +53,12 @@ * <pre> * MassToFormulaTool mf = new MassToFormulaTool(); * double myMass = 133.004242; - * ArrayList<IMolecularFormula> resultsMF = mf.generate(myMass); + * IMolecularFormulaSet mfSet = 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). + * <p>The elements are listed according on difference with the proposed mass. * - * @author Miguel Rojas + * @author rojasm * * @cdk.module experimental * @cdk.svnrev $Revision: 9162 $ @@ -67,23 +67,10 @@ private LoggingTool logger = new LoggingTool(MassToFormulaTool.class); - /** The mass which is calculate the molecular formula. */ - private double mass; - protected IChemObjectBuilder builder = DefaultChemObjectBuilder.getInstance(); - - /** Elements that must be presents in the molecular formula. As default they - * are O,N,C and H*/ - private IElement_Nr[] elemToCond = generateElemDefault(); - - /** 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 double charge = 0; /** matrix to follow for the permutations*/ private int[][] matrix_Base; @@ -91,79 +78,113 @@ /** Array listing the order of the elements to be shown according probability occurrence*/ private String[] orderElements; + /** The restrictions class. Specify the restrictions to apply*/ + private Restrictions restrictions; + /** - * Construct an instance of MassToFormulaTool. + * Construct an instance of MassToFormulaTool. It is necessary because different + * matrix have to build. Furthermore the default restrictions are initiated. + * + * @see #setDefaultRestrictions() */ public MassToFormulaTool() { factory = AtomTypeFactory.getInstance(new ChemObject().getBuilder()); - this.matrix_Base = callMatrix(elemToCond.length); + this.matrix_Base = callMatrix(4); this.orderElements = generateOrderE(); + setDefaultRestrictions(); + } + /** - * 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. + * Set the restrictions that must be presents in the molecular formula. * - * @param elemToCon IElements that must be presents - * @see #setElements(org.openscience.cdk.tools.MassToFormulaTool.IElement_Nr[]) + * @param restrictions The restrictions to impose + * + * @see #getRestrictions() + * @see #setRestrictionsDefault() */ - 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); + public void setRestrictions(Restrictions restrictions){ + + if(restrictions.getElements().size() == 0){ + /* Default restriction elements*/ + restrictions.addElement("O",0,15); + restrictions.addElement("N",0,15); + restrictions.addElement("C",0,15); + restrictions.addElement("H",0,15); }else{ + List<IElement_Nr> elements = ordningElements(restrictions.getElements()); + restrictions.removeAllElements(); + Iterator<IElement_Nr> iter = elements.iterator(); + while(iter.hasNext()){ + IElement_Nr element = iter.next(); + restrictions.addElement(element.getMyElement().getSymbol(), element.getOccurrenceMin(), element.getOccurrenceMax()); + } + } + + if(restrictions.getElements() != null) logger.error("The list IElement object is null or not contain elements"); -// return null; - } - + + if(restrictions.getElements().size() > 5) + logger.error("The list of Element is too big"); + + if(matrix_Base[1].length != restrictions.getElements().size()) + this.matrix_Base = callMatrix(restrictions.getElements().size()); + } + /** - * 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. + * Get the restrictions that must be presents in the molecular formula. * - * @param elemToCon IElements_Nr - * @see #setElements(IElement[]) + * @return The restrictions imposed + * + * @see #getRestrictions(Restrictions) + * @see #setDefaultRestrictions() */ - 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); + public Restrictions getRestrictions(){ + return this.restrictions; } + /** - * Set the charge of the molecule. As default is 0, meaning neutral compound. + * Set the default restrictions that must be presents in the molecular formula. * - * @param charge The charge value + * @return The restrictions imposed + * + * @see #getRestrictions(Restrictions) + * @see #setDefaultRestrictions() */ - public void setCharge(double charge){ - this.charge = charge; + public void setDefaultRestrictions(){ + callDefaultRestrictions(); } + /** - * Set the mass tolerance. As Default 0.05 uma. + * create the default restrictions. They are:<p> * - * @param tolerance The mass tolerance value + * Elements = C, H, O and N<p> + * Charge = 0.0, indicating neutral compound<p> + * Tolerance = 0.05 amu<p> + * */ - public void setTolerance(double tolerance){ - this.tolerance = tolerance; + private void callDefaultRestrictions() { + restrictions = new Restrictions(); + + /* Restriction elements*/ + restrictions.addElement("O",0,15); + restrictions.addElement("N",0,15); + restrictions.addElement("C",0,15); + restrictions.addElement("H",0,15); + + + /* Restriction charge*/ + restrictions.setCharge(0.0); + + /* Restriction charge*/ + restrictions.setTolerance(0.05); + + this.matrix_Base = callMatrix(restrictions.getElements().size()); + } /** * Method that actually does the work of extracting the molecular formula. @@ -171,26 +192,24 @@ * @param mass molecular formula to create from the mass * @return the filled molecular formula as ArrayList */ - public List<IMolecularFormula> generate(double mass) { - - ArrayList<IMolecularFormula> solutions_found = new ArrayList<IMolecularFormula>(); + public IMolecularFormulaSet generate(double mass) { + IMolecularFormulaSet molecularFormulaSet = new MolecularFormulaSet(); + if(mass == 0.0){ logger.error("Proposed mass is not valid: ",mass); - return null; - }else - this.mass = mass; + return molecularFormulaSet; + } - - int[][] matrix = this.matrix_Base; - + int numberElements = restrictions.getElements().size(); + double tolerance = restrictions.getTolerance(); + List<IElement_Nr> elements_TO = restrictions.getElements(); 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++){ + int[] value_In = new int[numberElements]; + for(int j= 0; j < numberElements ; j++){ if(matrix[i][j] == 0) value_In[j] = 0; else @@ -213,14 +232,14 @@ while(flag){ /*Find max occurence given a mass for a element with minimal elements*/ - int occurence = getMaxOccurence(mass, elem_Pos.get(possChan).intValue(),value_In,elemToCond); + int occurence = getMaxOccurence(mass, elem_Pos.get(possChan).intValue(),value_In,elements_TO); /*at least one*/ if (occurence == 0) break; - int maxx = elemToCond[elem_Pos.get(possChan).intValue()].getOccurrenceMax(); - int minn = elemToCond[elem_Pos.get(possChan).intValue()].getOccurrenceMin(); + int maxx = elements_TO.get(elem_Pos.get(possChan).intValue()).getOccurrenceMax(); + int minn = elements_TO.get(elem_Pos.get(possChan).intValue()).getOccurrenceMin(); /*restriction of the number of max and min number for a element*/ if(occurence < minn | maxx < occurence){ /* when is not in the occurrence that means that we have to @@ -267,12 +286,12 @@ /*set the occurrence into the matrix*/ value_In[elem_Pos.get(possChan).intValue()] = occurence; - double massT = calculateMassT(elemToCond,value_In); + double massT = calculateMassT(elements_TO,value_In); double diff_new = Math.abs(mass - (massT)); if(diff_new < tolerance){ - IMolecularFormula myMF = getFormula(elemToCond,value_In); - solutions_found.add(myMF); + IMolecularFormula myMF = getFormula(elements_TO,value_In); + molecularFormulaSet.addMolecularFormula(myMF); } if(count_E == 1)/*only valid for the first random 1000*/ @@ -308,34 +327,38 @@ } - return returnOrdered(solutions_found); + return returnOrdered(mass, molecularFormulaSet); } /** * Put in order the element according their mass * - * @param elemToCond2 The elements + * @param elemToCond The List of elements * @return List with the elements put in order */ - private IElement_Nr[] ordningElements(IElement_Nr[] elemToCond2) { - IElement_Nr[] elemToCond_pro = elemToCond; - IElement_Nr[] elemToCond_new = new IElement_Nr[elemToCond.length]; + private List<IElement_Nr> ordningElements(List<IElement_Nr> elemToCond) { + List<IElement_Nr> elemToCond_pro = new ArrayList<IElement_Nr>(); + for (int i = 0; i < elemToCond.size() ; i++){ + elemToCond_pro.add(elemToCond.get(i)); + } + List<IElement_Nr> elemToCond_new = new ArrayList<IElement_Nr>(); int pos = 0; - for (int i = 0; i < elemToCond.length ; i++){ + for (int i = 0; i < elemToCond.size() ; i++){ double valueMax = 0; int j_final = 0; - for (int j = 0 ; j < elemToCond_pro.length; j++){ - if (elemToCond_pro[j] == null) + for (int j = 0 ; j < elemToCond_pro.size(); j++){ + if (elemToCond_pro.get(j) == null) continue; - double atomicN = elemToCond_pro[j].getMajorIsotope().getExactMass(); + double atomicN = elemToCond_pro.get(j).getMajorIsotope().getExactMass(); if (valueMax < atomicN){ valueMax = atomicN; j_final = j; } } - elemToCond_new[pos] = (IElement_Nr)elemToCond_pro[j_final]; - elemToCond_pro[j_final] = null; + IElement_Nr element_tmp = elemToCond_pro.get(j_final); + elemToCond_new.add(element_tmp); + elemToCond_pro.remove(j_final); pos++; } @@ -376,13 +399,13 @@ * @param elemToCond_new * @return */ - private int getMaxOccurence(double massTo, int element_pos, int[] matrix,IElement_Nr[] elemToCond_new) { - double massIn = elemToCond_new[element_pos].getMajorIsotope().getExactMass(); + private int getMaxOccurence(double massTo, int element_pos, int[] matrix,List<IElement_Nr> elemToCond_new) { + double massIn = elemToCond_new.get(element_pos).getMajorIsotope().getExactMass(); double massToM = massTo; for(int i = 0; i < matrix.length ; i++) if (i != element_pos) if(matrix[i] != 0) - massToM -= elemToCond_new[i].getMajorIsotope().getExactMass()*matrix[i]; + massToM -= elemToCond_new.get(i).getMajorIsotope().getExactMass()*matrix[i]; int value = (int)((massToM+1)/massIn); @@ -396,11 +419,11 @@ * @param value_In * @return The IMolecularFormula */ - private IMolecularFormula getFormula(IElement_Nr[] elemToCond_new, int[] value_In) { + private IMolecularFormula getFormula(List<IElement_Nr> elemToCond_new, int[] value_In) { IMolecularFormula mf = new MolecularFormula();; - for(int i = 0; i < elemToCond_new.length ; i++){ + for(int i = 0; i < elemToCond_new.size() ; i++){ if(value_In[i] != 0){ - mf.addElement(elemToCond_new[i].getMyElement(),value_In[i]); + mf.addElement(elemToCond_new.get(i).getMyElement(),value_In[i]); } } mf = putInOrder(mf); @@ -421,7 +444,7 @@ new_mf.addElement(element, mf.getAtomCount(element)); } } - new_mf.setCharge(charge); +// new_mf.setCharge(charge); return new_mf; } /** @@ -431,39 +454,39 @@ * @param value_In The occurrences * @return The sum total */ - private double calculateMassT(IElement_Nr[] elemToCond_new, int[] value_In) { + private double calculateMassT(List<IElement_Nr> elemToCond_new, int[] value_In) { double result = 0; - for(int i = 0; i < elemToCond_new.length ; i++){ + for(int i = 0; i < elemToCond_new.size() ; i++){ if(value_In[i] != 0){ - result += elemToCond_new[i].getMajorIsotope().getExactMass()*value_In[i]; + result += elemToCond_new.get(i).getMajorIsotope().getExactMass()*value_In[i]; } } return result; } - /** - * generate all elements that will be present as default. They - * are C, H, O and N. - * - * @return The group of IElement_Nr as default - */ - private IElement_Nr[] generateElemDefault(){ - IElement_Nr[] elemDefault = new IElement_Nr[4]; - - elemDefault[0] = new IElement_Nr("C",0,9); - elemDefault[1] = new IElement_Nr("H",0,9); - elemDefault[2] = new IElement_Nr("O",0,9); - elemDefault[3] = new IElement_Nr("N",0,9); - return elemDefault; - } +// /** +// * generate all elements that will be present as default. They +// * are C, H, O and N. +// * +// * @return The group of IElement_Nr as default +// */ +// private IElement_Nr[] generateElemDefault(){ +// IElement_Nr[] elemDefault = new IElement_Nr[4]; +// +// elemDefault[0] = new IElement_Nr("C",0,9); +// elemDefault[1] = new IElement_Nr("H",0,9); +// elemDefault[2] = new IElement_Nr("O",0,9); +// elemDefault[3] = new IElement_Nr("N",0,9); +// return elemDefault; +// } - /** - * returns the exact mass used to calculate the molecular formula. - * - * @return The mass value - */ - public double getMass() { - return mass; - } +// /** +// * returns the exact mass used to calculate the molecular formula. +// * +// * @return The mass value +// */ +// public double getMass() { +// return mass; +// } /** * subclass of IElement which informs about the number @@ -543,28 +566,28 @@ * * @return The molecularFormula in an ArrayList */ - private ArrayList<IMolecularFormula> returnOrdered(ArrayList<IMolecularFormula> molecularFormula){ - ArrayList<IMolecularFormula> solutions_new = null; + private IMolecularFormulaSet returnOrdered(double mass, IMolecularFormulaSet molecularFormulaSet){ + IMolecularFormulaSet solutions_new = null; IsotopeFactory ifac; try { ifac = IsotopeFactory.getInstance(builder); - if(molecularFormula.size() != 0){ + if(molecularFormulaSet.getMolecularFormulaCount() != 0){ - ArrayList<IMolecularFormula> solutions_pro = molecularFormula; - solutions_new = new ArrayList<IMolecularFormula>(); - for (int i = 0; i < molecularFormula.size() ; i++){ + IMolecularFormulaSet solutions_pro = molecularFormulaSet; + solutions_new = molecularFormulaSet.getBuilder().newMolecularFormulaSet(); + for (int i = 0; i < molecularFormulaSet.getMolecularFormulaCount() ; i++){ double valueMin = 100; int j_final = 0; - for (int j = 0 ; j < solutions_pro.size() ; j++){ - IAtomContainer newAC = solutions_pro.get(j).getBuilder().newAtomContainer(); - Iterator<IElement> iterator = solutions_pro.get(j).elements(); + for (int j = 0 ; j < solutions_pro.getMolecularFormulaCount() ; j++){ + IAtomContainer newAC = solutions_pro.getMolecularFormula(j).getBuilder().newAtomContainer(); + Iterator<IElement> iterator = solutions_pro.getMolecularFormula(j).elements(); while(iterator.hasNext()){ IElement element = iterator.next(); double maxIsotop = ifac.getMajorIsotope(element.getSymbol()).getExactMass(); - int rep = solutions_pro.get(j).getAtomCount(element); + int rep = solutions_pro.getMolecularFormula(j).getAtomCount(element); for(int z = 0; z < rep; z++){ - IAtom atom = solutions_pro.get(j).getBuilder().newAtom(element); + IAtom atom = solutions_pro.getMolecularFormula(j).getBuilder().newAtom(element); atom.setExactMass(maxIsotop); newAC.addAtom(atom); } @@ -580,8 +603,8 @@ } - solutions_new.add(solutions_pro.get(j_final)); - solutions_pro.remove(j_final); + solutions_new.addMolecularFormula(solutions_pro.getMolecularFormula(j_final)); + solutions_pro.removeMolecularFormula(j_final); } } @@ -711,4 +734,84 @@ {1,1,1,1,1,1}}; // 6 return matrix; } + + /** + * Class which defines the restrictions + * + * @author rojasm + * + */ + public class Restrictions{ + List<IElement_Nr> elements; + private double charge; + private double tolerance; + /** + * Constructor of Restrictions object + */ + public Restrictions(){ + elements = new ArrayList<IElement_Nr>(); + charge = 0.0; + tolerance = 0.05; + } + /** + * add a specific restriction. + * + * @param oneRestriction The Restrictions object + */ + public void addElement(String symbol, int min, int max){ + elements.add(new IElement_Nr(symbol,min,max)); + + } + /** + * get the element to restrict. + * + * @return An ArrayList with the elements to restrict + */ + public List<IElement_Nr> getElements(){ + return this.elements; + + } + /** + * set the tolerance which to restrict. + * + * @param tolerance The tolerance value + */ + public void setTolerance(double tolerance){ + this.tolerance = tolerance; + } + + /** + * get the tolerance which will applied to restrict. + * + * @return the tolerance value + */ + public double getTolerance(){ + return this.tolerance; + } + + /** + * set the charge which to restrict. + * + * @param charge The charge value + */ + public void setCharge(double charge){ + this.charge = charge; + } + + /** + * get the charge which will applied to restrict. + * + * @return the charge value + */ + public double getCharge(){ + return this.charge; + } + + /** + * remove all restrictions. + */ + public void removeAllElements(){ + elements = new ArrayList<IElement_Nr>(); + } + } } This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site. |