Changes in / [20:30]


Ignore:
Location:
/trunk
Files:
17 added
1 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • /trunk/JavaLCMSTools/src/export/mzXML/ExportLCMSSpectraToMzXML.java

    r20 r30  
    231231
    232232                scanXMLNode.setAttribute("num", scanCount.toString());
    233                 scanOpen = "<scan num=\""+scanCount.toString() + "\"";
     233                scanOpen = "<scan num=\""+scanCount.toString() + "\" ";
    234234               
    235235                String rTime = "PT" + rtMin*60 +"S";
    236236                scanXMLNode.setAttribute("retentionTime", rTime);
    237                 scanOpen = scanOpen + "retentionTime=\""+rTime + "\"";
     237                scanOpen = scanOpen + "retentionTime=\""+rTime + "\" ";
    238238               
    239239                scanXMLNode.setAttribute("polarity", "+");
    240                 scanOpen = scanOpen + "polarity=\""+"+" + "\"";
     240                scanOpen = scanOpen + "polarity=\""+"+" + "\" ";
    241241               
    242242                scanXMLNode.setAttribute("msLevel", "1");
    243                 scanOpen = scanOpen + "msLevel=\""+"1" + "\"";
     243                scanOpen = scanOpen + "msLevel=\""+"1" + "\" ";
    244244               
    245245                Integer peakCount = mSpectra.getPoints(false).size();
    246246                scanXMLNode.setAttribute("peaksCount", peakCount.toString());
    247                 scanOpen = scanOpen + "peaksCount=\""+peakCount.toString() + "\"";
     247                scanOpen = scanOpen + "peaksCount=\""+peakCount.toString() + "\" ";
    248248               
    249249                float lowMz = ((Double)mSpectra.getFirstMass()).floatValue();
     
    251251
    252252                scanXMLNode.setAttribute("lowMz", ((Float)lowMz).toString());
    253                 scanOpen = scanOpen + "lowMz=\""+((Float)lowMz).toString() + "\"";
     253                scanOpen = scanOpen + "lowMz=\""+((Float)lowMz).toString() + "\" ";
    254254               
    255255                scanXMLNode.setAttribute("highMz", ((Float)highMz).toString());
    256                 scanOpen = scanOpen + "highMz=\""+((Float)highMz).toString() + "\"";
     256                scanOpen = scanOpen + "highMz=\""+((Float)highMz).toString() + "\" ";
    257257               
    258258                Double basePeakIntens = mSpectra.getMaximumIntensitie();
     
    260260               
    261261                scanXMLNode.setAttribute("basePeakMZ", basePeakMZ.toString());
    262                 scanOpen = scanOpen + "basePeakMZ=\""+basePeakMZ.toString() + "\"";
     262                scanOpen = scanOpen + "basePeakMZ=\""+basePeakMZ.toString() + "\" ";
    263263               
    264264                scanXMLNode.setAttribute("basePeakIntensity", basePeakIntens.toString());
    265                 scanOpen = scanOpen + "basePeakIntensity=\""+basePeakIntens.toString() + "\"";
     265                scanOpen = scanOpen + "basePeakIntensity=\""+basePeakIntens.toString() + "\" ";
    266266               
    267267                Double sum = mSpectra.getIntensityStats().getStats().getSum();
    268268                scanXMLNode.setAttribute("totIonCurrent", sum.toString());
    269                 scanOpen = scanOpen + "totIonCurrent=\""+sum.toString() + "\"";
     269                scanOpen = scanOpen + "totIonCurrent=\""+sum.toString() + "\" ";
    270270               
    271271                scanOpen = scanOpen + ">\n";
  • /trunk/JavaLCMSTools/src/export/svg/ExportLCTraceSpectraToSVG.java

    r20 r30  
    168168                if(pngPicture) {
    169169                        if(doNotRename == false) {
    170                                 exportChartAsSVG(chart,bounds,fileName+".png");
     170                                exportChartAsPNG(chart,bounds,fileName+".png");
    171171                        } else {
    172                                 exportChartAsSVG(chart,bounds,fileName);
     172                                exportChartAsPNG(chart,bounds,fileName);
    173173                        }
    174174                }
  • /trunk/JavaLCMSTools/src/lcSpectra/LCMSSpectra.java

    r20 r30  
    594594                }
    595595        }
     596
     597        /**
     598         * Returns the number of included Datapoints!!
     599         *
     600         * @return
     601         */
     602        public int getNumberDataPoints() {
     603                int result = 0;
     604               
     605                Iterator<Double> itRts = lcMSrun.keySet().iterator();
     606                while(itRts.hasNext()) {
     607                        MassSpectraC msc = lcMSrun.get(itRts.next());
     608                        result = result + msc.getPoints(false).size();
     609                }
     610               
     611                return result;
     612        }
    596613}
  • /trunk/JavaLCMSTools/src/statistics/basic/NumberSerie.java

    r20 r30  
    113113                if(size % 2 == 0) {
    114114                        median = values.get(size/2);
     115                } if (size == 1) {
     116                        median = values.get(0);
    115117                } else {
    116118                        double med1 = values.get(size/2);
  • /trunk/JavaLCMSTools/src/statistics/basic/StatsNormal.java

    r20 r30  
    3434                sumValues = 0;
    3535                non = 0;
    36                 max   = Double.MIN_VALUE;
    37                 min   = Double.MAX_VALUE;
     36                max   = Double.MIN_VALUE*2;
     37                min   = Double.MAX_VALUE/2;
    3838                mean  = 0;
    3939                stdev = 0;
     
    8888                while(viIt.hasNext()) {
    8989                       
    90                         double value = viIt.next();
     90                        Double value = viIt.next();
    9191                       
    92                         sumValues += value;
    93                         sumSquareValues += (value*value);
     92                        if(value != null) {
    9493                       
    95                         if(value < min) {
    96                                 min = value;
     94                                sumValues += value;
     95                                sumSquareValues += (value*value);
     96                               
     97                                if(value < min) {
     98                                        min = value;
     99                                }
     100                                if(value > max) {
     101                                        max = value;
     102                                }
     103                               
     104                                non++;
    97105                        }
    98                         if(value > max) {
    99                                 max = value;
    100                         }
    101                        
    102                         non++;
    103106                }
    104107               
  • /trunk/msCompare/src/dataStructures/misc/TabExport.java

    r20 r30  
    99        private List<TabExportNode> direct              = new ArrayList<TabExportNode>();
    1010        private List<TabExportNode> perSample   = new ArrayList<TabExportNode>();
     11        private List<TabExportNode> perClass    = new ArrayList<TabExportNode>();
    1112       
    1213        private String separator = "\t";
    13        
    14        
     14
    1515        public List<TabExportNode> getDirectExportNodes() {
    1616                return direct;
    17         }
    18        
    19         public void addDirectExportNode(TabExportNode ten) {
    20                 direct.add(ten);
    2117        }
    2218       
     
    2521        }
    2622       
    27         public void addPerSampleExportNode(TabExportNode ten) {
    28                 perSample.add(ten);
     23        public List<TabExportNode> getPerClassExportNodes() {
     24                return perClass;
    2925        }
    3026       
     
    4238                } else if (ten.getType().equalsIgnoreCase(TabExportNode.typePerSample)) {
    4339                        perSample.add(ten);
     40                } else if (ten.getType().equalsIgnoreCase(TabExportNode.typePerClass)) {
     41                        perClass.add(ten);
    4442                }
    4543        }
  • /trunk/msCompare/src/dataStructures/misc/TabExportNode.java

    r20 r30  
    1313        public static final String typeDirect           = "Direct";
    1414        public static final String typePerSample        = "PerSample";
     15        public static final String typePerClass         = "PerClass";
    1516               
    1617        private String  name = null;
  • /trunk/msCompare/src/runProgram/ProgramList.java

    r20 r30  
    4242import runProgram.programParts.superHirn.RunSuperHirn;
    4343import runProgram.programParts.twoDimensionalLCMS.AlignmentOf2DLC;
     44import runProgram.programParts.twoDimensionalLCMS.CombineSplitPeaks2DLC;
    4445import runProgram.programParts.twoDimensionalLCMS.FractionSplitter;
    4546import runProgram.programParts.twoDimensionalLCMS.MatchingOf2DLC;
     
    145146                } else if (programName.equalsIgnoreCase(ResolveOverlappingFeatures2DLCMS.program)) {
    146147                        program = new ResolveOverlappingFeatures2DLCMS();
     148                } else if (programName.equalsIgnoreCase(CombineSplitPeaks2DLC.program)) {
     149                        program = new CombineSplitPeaks2DLC();
    147150                }
    148151               
  • /trunk/msCompare/src/runProgram/RunProgramsLocal.java

    r20 r30  
    2424        private int counter = 0;
    2525       
    26         private int numberOfCores = 5;
     26        private int numberOfCores = 8;
    2727
    2828        private boolean writeParameterFile = false; //Not supported Atm!!
  • /trunk/msCompare/src/runProgram/programParts/genericImporters/DelimitedPeakListImporter.java

    r20 r30  
    1515import runProgram.AbstractRunProgram;
    1616
     17/**
     18 * TODO FINISH Writing this.
     19 *
     20 * @author berend
     21 *
     22 */
    1723public class DelimitedPeakListImporter extends AbstractRunProgram {
    1824       
  • /trunk/msCompare/src/runProgram/programParts/openMS/RunOpenMSV15.java

    r20 r30  
    807807                boolean success = (new File(tmpDir)).mkdir();
    808808                if(!success) {
    809                         throw new IOException("Could not create directory"+tmpDir);
     809                       
     810                        Thread.sleep(1000);
     811                        success = (new File(tmpDir)).mkdir();
     812                       
     813                        if(!success) {
     814                                throw new IOException("Could not create directory: "+tmpDir);
     815                        }
    810816                }
    811817               
     
    958964                String uniqueNumber = ((Long)System.currentTimeMillis()).toString();
    959965                String tmpDir = tmpBaseDir + File.separator +"openMS_"+uniqueNumber+File.separator;
    960                 String openMSResultFile = tmpDir + File.separator + "openMS_result_"+uniqueNumber+".xml";
    961966               
    962967                boolean success = (new File(tmpDir)).mkdir();
    963968                if(!success) {
    964                         throw new IOException("Could not create directory"+tmpDir);
    965                 }
     969                        Thread.sleep(1000+(long)(Math.random()*1000));
     970                        tmpDir = tmpDir + "_" + ((Long)System.currentTimeMillis()).toString();
     971                        success = (new File(tmpDir)).mkdir();
     972                       
     973                        if(!success) {
     974                                throw new IOException("Could not create directory"+tmpDir);
     975                        }
     976                }       
     977                String openMSResultFile = tmpDir + File.separator + "openMS_result_"+uniqueNumber+".xml";
    966978               
    967979                int nonFiles = param.getInputFiles().getInputFiles().size();
  • /trunk/msCompare/src/runProgram/programParts/twoDimensionalLCMS/ResolveOverlappingFeatures2DLCMS.java

    r20 r30  
    22
    33import java.io.File;
     4import java.io.IOException;
    45import java.util.ArrayList;
    56import java.util.Collections;
     
    89import java.util.Iterator;
    910import java.util.ListIterator;
    10 
     11import java.util.Set;
     12
     13import loadData.peakList.LoadPeakGeneralList;
     14
     15import org.apache.commons.io.FileUtils;
    1116import org.apache.commons.math.MathException;
    1217import org.apache.commons.math.analysis.interpolation.LoessInterpolator;
    1318import org.jfree.data.xy.XYSeries;
    1419
    15 import loadData.peakList.LoadPeakGeneralList;
    16 import matlabMathFunctions.MVector;
    1720import runProgram.AbstractRunProgram;
    1821import saveData.peakList.PeakListSaver;
     
    2124import saveData.peakMatrix.SavePeakMatrixXML;
    2225import statistics.basic.StatsNormal;
    23 import statistics.basic.XYSerie;
    2426import dataStructures.misc.parameters.Parameters;
    2527import dataStructures.misc.parameters.helpers.parameterInterfaces.FileType;
    2628import dataStructures.misc.parameters.helpers.parameterTypes.PeakListGeneralFileType;
    27 import dataStructures.misc.parameters.helpers.parameterTypes.PeakMatrixFileType;
    2829import dataStructures.peakMatrix.MatchedPeak;
    2930import dataStructures.peakMatrix.PeakMatrix;
     
    3738
    3839        private final String inclusionCountTreshold = "inclusionCountTreshold";
     40       
     41        private final String maxDistanceFromFit = "maxRetentionTimeDifferenceWithLOESSFit";
     42        private final String loessBaundWidth = "LOESS_BandWidth";
     43        private final String loessIterations = "LOESS_iterations";
    3944               
    4045        public static String program = "ResolveOverlappingFeatures2DLC";
     
    99104                Iterator<String> itInput = param.getInputFiles().getInputFiles().iterator();
    100105                HashMap<Integer,HashMap<Integer,ArrayList<FeaturePosition>>> features = new HashMap<Integer,HashMap<Integer,ArrayList<FeaturePosition>>>();
    101                                
    102                 while(itInput.hasNext()) {
    103                         String inputFile = itInput.next();
    104                         LoadPeakGeneralList lpgl = new LoadPeakGeneralList();
    105                         File tmpBaseDir = new File(param.getParameters().getAttributeValue(tmpDir));
    106                         PeakGeneralList peakList = lpgl.loadPeakList(inputFile, tmpBaseDir);
    107                        
    108                         Integer clNum = param.getInputFiles().getClassNumberForInputFile(inputFile);
    109                         Integer frNum = param.getInputFiles().getFractionNumberForInputFile(inputFile);
    110                        
    111                         if(!features.containsKey(frNum)) {
    112                                 features.put(frNum, new HashMap<Integer,ArrayList<FeaturePosition>>());
    113                         }
    114                         if(!features.get(frNum).containsKey(clNum)) {
    115                                 features.get(frNum).put(clNum, new ArrayList<FeaturePosition>());
    116                         }
    117                
    118                         Iterator<PeakGeneral> itPG = peakList.getPeakList().iterator();
    119                         while(itPG.hasNext()) {
    120                                
    121                                 PeakGeneral pg = itPG.next();
    122                                
    123                                 FeaturePosition fp = new FeaturePosition();
    124                                
    125                                 fp.classNum = clNum.intValue();
    126                                 fp.fractionNum = frNum.intValue();
    127                                 fp.fileName = inputFile;
    128                                 fp.pg = pg;
    129                                
    130                                 double rtPG = pg.getAttribute("coordinateFeature:rt", "APMLGenerated").getDoubleValue().doubleValue();
    131                                 double mzPG = pg.getAttribute("coordinateFeature:mz", "APMLGenerated").getDoubleValue().doubleValue();
    132                                
    133                                 fp.rt = rtPG;
    134                                 fp.mz = mzPG;
    135                                
    136                                 features.get(frNum).get(clNum).add(fp);
    137                                
    138                         }
    139                 }
    140                
    141                 ArrayList<Integer> frNums = new ArrayList<Integer>(features.keySet());
    142                 Collections.sort(frNums);
    143                
     106               
     107                HashMap<Integer,Integer> pairs = new HashMap<Integer,Integer>();
     108                HashMap<Integer,Integer> maxSamplesPerClass = new HashMap<Integer,Integer>();
     109                       
    144110                HashSet<Integer> exclusionListFractionNumbers = new HashSet<Integer>();
    145111                exclusionListFractionNumbers.add(1);                                                                                     
     
    151117                exclusionListFractionNumbers.add(15); exclusionListFractionNumbers.add(16);
    152118                exclusionListFractionNumbers.add(17); exclusionListFractionNumbers.add(18);
    153                 exclusionListFractionNumbers.add(19); exclusionListFractionNumbers.add(20);             
     119                exclusionListFractionNumbers.add(19); exclusionListFractionNumbers.add(20);
     120               
     121                while(itInput.hasNext()) {
     122                        String inputFile = itInput.next();
     123                        LoadPeakGeneralList lpgl = new LoadPeakGeneralList();
     124                        File tmpBaseDir = new File(param.getParameters().getAttributeValue(tmpDir));
     125                       
     126                       
     127                        Integer clNum = param.getInputFiles().getClassNumberForInputFile(inputFile);
     128                        Integer frNum = param.getInputFiles().getFractionNumberForInputFile(inputFile);
     129                       
     130                        if(!features.containsKey(frNum)) {
     131                                features.put(frNum, new HashMap<Integer,ArrayList<FeaturePosition>>());
     132                        }
     133                        if(!features.get(frNum).containsKey(clNum)) {
     134                                features.get(frNum).put(clNum, new ArrayList<FeaturePosition>());
     135                        }
     136                       
     137                        //Keeps track of the max number of samples per class!!
     138                        if(maxSamplesPerClass.containsKey(frNum)) {
     139                                Integer value = maxSamplesPerClass.get(frNum);
     140                                value = value + 1;
     141                                maxSamplesPerClass.put(frNum, value);
     142                        } else {
     143                                maxSamplesPerClass.put(frNum, 1);
     144                        }
     145
     146                        if(!exclusionListFractionNumbers.contains(frNum)) {
     147                                PeakGeneralList peakList = lpgl.loadPeakList(inputFile, tmpBaseDir);
     148                                Iterator<PeakGeneral> itPG = peakList.getPeakList().iterator();
     149                                while(itPG.hasNext()) {
     150                                       
     151                                        PeakGeneral pg = itPG.next();
     152                                       
     153                                        FeaturePosition fp = new FeaturePosition();
     154                                       
     155                                        fp.classNum = clNum.intValue();
     156                                        fp.fractionNum = frNum.intValue();
     157                                        fp.fileName = inputFile;
     158                                        fp.pg = pg;
     159                                       
     160                                        double rtPG = pg.getAttribute("coordinateFeature:rt", "APMLGenerated").getDoubleValue().doubleValue();
     161                                        double mzPG = pg.getAttribute("coordinateFeature:mz", "APMLGenerated").getDoubleValue().doubleValue();
     162                                       
     163                                        fp.rt = rtPG;
     164                                        fp.mz = mzPG;
     165                                       
     166                                        features.get(frNum).get(clNum).add(fp);
     167                                       
     168                                }
     169                        }
     170                }
     171               
     172                ArrayList<Integer> frNums = new ArrayList<Integer>(features.keySet());
     173                Collections.sort(frNums);       
    154174               
    155175                ArrayList<Cluster> allClusters = new ArrayList<Cluster>();
     
    164184                                HashMap<Integer,ArrayList<FeaturePosition>> hmCurrent = features.get(current);
    165185                               
     186                                pairs.put(previous, current);
     187                               
    166188                                ArrayList<Cluster> cluster = getAllMatchedFeatureCombinations(hmPrevious,hmCurrent,param);
    167189                                allClusters.addAll(cluster);
     
    175197                System.err.println("All clusters Size: " + allClusters.size());
    176198               
    177                 ArrayList<Cluster> filteredClusters = filterAllClusters(allClusters);
    178                
    179                 System.err.println("filteredClusters Size: " + filteredClusters.size() + "(After filtering out duplico's)");
    180        
    181                 ArrayList<Cluster> fittedClustersAll = fitClusters(allClusters);
    182                 ArrayList<Cluster> fittedClusters = fitClusters(filteredClusters);
    183                
    184                
    185                
    186                 ArrayList<Cluster> filteredFittedClusters = filterAllClusters(fittedClustersAll);
    187 
    188                 System.err.println("fittedClusters Size: " + fittedClusters.size() + "(Fitted clusters based on filtered result)");
    189                 System.err.println("fittedClusters Size: " + fittedClustersAll.size() + "(Matching fitted clusters based on all)");
     199//              ArrayList<Cluster> filteredClusters = filterDuplicateClusters(allClusters);
     200//              System.err.println("filteredClusters Size: " + filteredClusters.size() + "(After filtering out duplico's)");
     201               
     202                ArrayList<Cluster> fittedClustersAll = fitClusters(allClusters,pairs, param);
     203//              ArrayList<Cluster> fittedClusters = fitClusters(filteredClusters,pairs, param);
     204               
     205               
     206               
     207                ArrayList<Cluster> filteredFittedClusters = filterDuplicateClusters(fittedClustersAll);
     208
     209//              System.err.println("fittedClusters Size: " + fittedClusters.size() + "(Fitted clusters based on filtered result)");
     210//              System.err.println("fittedClusters Size: " + fittedClustersAll.size() + "(Matching fitted clusters based on all)");
    190211                System.err.println("filteredFittedClusters Size: " + filteredFittedClusters.size() + "(Matching fitted clusters based on all, and filtered afterwards)");
    191                
     212
     213                System.err.println();
     214                System.err.println("Removing Cluster which are too small now!!");
     215               
     216                //Get threshold
     217                double threshold = param.getParameters().getAttributeDoubleValue(inclusionCountTreshold);
     218               
     219                //Remove clusters which have become too small!!
     220                filteredFittedClusters  = filterClusterSize(filteredFittedClusters,threshold,maxSamplesPerClass);
     221               
     222                System.err.println("filteredFittedClusters Size: " + filteredFittedClusters.size() + "(Matching fitted clusters based on all, and filtered afterwards)");
     223               
     224                //Going from clusters to MatchedPeaks
    192225                ArrayList<MatchedPeak> mpListFilFitC = getMatchedPeaksFromClusters(filteredFittedClusters);
    193                 ArrayList<MatchedPeak> mpListFitFilC = getMatchedPeaksFromClusters(fittedClusters);
    194                 ArrayList<MatchedPeak> mpListFilC = getMatchedPeaksFromClusters(filteredClusters);
     226//              ArrayList<MatchedPeak> mpListFitFilC = getMatchedPeaksFromClusters(fittedClusters);
     227//              ArrayList<MatchedPeak> mpListFilC = getMatchedPeaksFromClusters(filteredClusters);
    195228                ArrayList<MatchedPeak> mpListAC = getMatchedPeaksFromClusters(allClusters);
    196229               
     
    199232                //Saving them in a separated file.
    200233                saveOverlappingPeaks(param, mpListFilFitC, "filteredFittedClusters.xml");
    201                 saveOverlappingPeaks(param, mpListFitFilC, "fittedFilteredClusters.xml");
    202                 saveOverlappingPeaks(param, mpListFilC, "filteredClusters.xml");
     234//              saveOverlappingPeaks(param, mpListFitFilC, "fittedFilteredClusters.xml");
     235//              saveOverlappingPeaks(param, mpListFilC, "filteredClusters.xml");
    203236                saveOverlappingPeaks(param, mpListAC, "AllClusters.xml");
    204237               
     
    208241                        String inputFile = itInput.next();
    209242                        LoadPeakGeneralList lpgl = new LoadPeakGeneralList();
    210                         File tmpBaseDir = new File(param.getParameters().getAttributeValue(tmpDir));
    211                         PeakGeneralList peakList = lpgl.loadPeakList(inputFile, tmpBaseDir);
    212                                                
     243                                                               
    213244                        //Gets the features for a certain fileName
    214245                        ArrayList<FeaturePosition> listFP = new ArrayList<FeaturePosition>();
     
    223254                        }
    224255                       
    225                         PeakGeneralList filteredPeakList = new PeakGeneralList(tmpBaseDir);
    226                         filteredPeakList.setPeakGeneralListProperties(peakList.getPeakGeneralListProperties());
    227                        
    228                         Iterator<PeakGeneral> itPG = peakList.getPeakList().iterator();
    229                         while(itPG.hasNext()) {
    230                                
    231                                 PeakGeneral pg = itPG.next();
    232                                 boolean add = true;
    233                        
    234                                 Iterator<FeaturePosition> itFP = listFP.iterator();
    235                                 while(itFP.hasNext()) {
    236                                         FeaturePosition fp = itFP.next();
    237                                        
    238                                         String unique = fp.pg.getUniqueTraceIdentifier();
    239                                         if(unique.equalsIgnoreCase(pg.getUniqueTraceIdentifier())){
    240                                                 add = false;
     256                        if(listFP.size() == 0) {
     257                               
     258                                String outputFile = param.getInputFiles().getOutputFileForInputFile(inputFile);
     259                                try {
     260                                        FileUtils.copyFile(new File(inputFile), new File(outputFile));
     261                                } catch (IOException e) {
     262                                        System.err.println("Failed to Copy (unmodified) File");
     263                                        e.printStackTrace();
     264                                }
     265                               
     266                        } else {
     267                                File tmpBaseDir = new File(param.getParameters().getAttributeValue(tmpDir));
     268                                PeakGeneralList peakList = lpgl.loadPeakList(inputFile, tmpBaseDir);
     269                               
     270                                PeakGeneralList filteredPeakList = new PeakGeneralList(tmpBaseDir);
     271                                filteredPeakList.setPeakGeneralListProperties(peakList.getPeakGeneralListProperties());
     272                               
     273                                Iterator<PeakGeneral> itPG = peakList.getPeakList().iterator();
     274                                while(itPG.hasNext()) {
     275                                       
     276                                        PeakGeneral pg = itPG.next();
     277                                        boolean add = true;
     278                               
     279                                        Iterator<FeaturePosition> itFP = listFP.iterator();
     280                                        while(itFP.hasNext()) {
     281                                                FeaturePosition fp = itFP.next();
     282                                               
     283                                                String unique = fp.pg.getUniqueTraceIdentifier();
     284                                                if(unique.equalsIgnoreCase(pg.getUniqueTraceIdentifier())){
     285                                                        add = false;
     286                                                }
    241287                                        }
    242                                 }
    243                                
    244                                 if(add) {
    245                                         filteredPeakList.addPeakGeneral(pg);
    246                                 }
    247                         }
    248                        
    249                         String outputFile = param.getInputFiles().getOutputFileForInputFile(inputFile);
    250                        
    251                         System.out.println("Saving filtered peaklist: " + outputFile  + "(Size before: " + peakList.getPeakList().size() + " Size after: " +  filteredPeakList.getPeakList().size());
    252                        
    253                         PeakListSaver pls = new SavePeakGeneralList();
    254                         pls.savePeakList(outputFile, filteredPeakList);
    255                 }
    256         }
    257 
    258 private void saveOverlappingPeaks(Parameters param, ArrayList<MatchedPeak> mpList, String fileName) {
    259         Iterator<String> itInput;
    260        
    261         String ipFile = param.getInputFiles().getInputFiles().iterator().next();
    262         File otFile = new File(param.getInputFiles().getOutputFileForInputFile(ipFile));
    263        
    264         String outputFileName =  otFile.getParent() + File.separator + fileName;
    265        
    266         //Add to the peakMatrix!! (for debug only atm ...)
    267         PeakMatrix peakMatrixResult = new PeakMatrix();
    268         peakMatrixResult.addMatchedPeaks(mpList);
    269 
    270         itInput = param.getInputFiles().getInputFiles().iterator();
    271         while(itInput.hasNext()) {
    272                 String inputFile = itInput.next();             
    273                 Integer clNum = param.getInputFiles().getClassNumberForInputFile(inputFile);
    274        
    275                 peakMatrixResult.addFileClassPair(inputFile, clNum);
    276         }
    277 
    278         AbstractSavePeakMatrix aspm = new SavePeakMatrixXML();
    279         aspm.savePeakMatrix(outputFileName, peakMatrixResult, null);
    280        
    281         additionalFiles.add(outputFileName);
    282 }
    283        
    284         private ArrayList<Cluster> fitClusters(ArrayList<Cluster> filteredClusters) {
    285                
     288                                       
     289                                        if(add) {
     290                                                filteredPeakList.addPeakGeneral(pg);
     291                                        }
     292                                }
     293                               
     294                                String outputFile = param.getInputFiles().getOutputFileForInputFile(inputFile);
     295                               
     296                                System.out.println("Saving filtered peaklist: " + outputFile  + "(Size before: " + peakList.getPeakList().size() + " Size after: " +  filteredPeakList.getPeakList().size());
     297                               
     298                                PeakListSaver pls = new SavePeakGeneralList();
     299                                pls.savePeakList(outputFile, filteredPeakList);
     300                        }
     301                }
     302        }
     303
     304        private ArrayList<Cluster> filterClusterSize(ArrayList<Cluster> filter, double postProcessThreshold, HashMap<Integer,Integer> maxSamplesPerClass) {
    286305                ArrayList<Cluster> result = new ArrayList<Cluster>();
    287        
    288                 Integer clA = 0;
    289                 Integer clB = 0;
    290 
    291                 HashSet<Integer> frNums = filteredClusters.get(0).getFractionNums();
    292                 if(frNums.size() == 2) {
    293                         Iterator<Integer> itIG = frNums.iterator();
    294                
    295                         clA = itIG.next();
    296                         clB = itIG.next();
    297                        
    298                        
    299                 } else {
    300                         System.err.println("frNums: " + frNums.size());
    301                 }
    302                
    303                 XYCSerie xySC = new XYCSerie();
    304                
    305                 ListIterator<Cluster> itCl = filteredClusters.listIterator();
     306               
     307                Iterator<Cluster> itCl = filter.iterator();
    306308                while(itCl.hasNext()) {
     309                       
    307310                        Cluster cl = itCl.next();
    308                        
    309                         StatsNormal stA = new StatsNormal();
    310                         StatsNormal stB = new StatsNormal();
    311                        
    312                         Iterator<FeaturePosition> itFe = cl.getFeaturesFraction(clA).iterator();
    313                         while(itFe.hasNext()) {
    314                                 double rt = itFe.next().rt;
    315                                 stA.setValue(rt);
    316                         }
    317                        
    318                         itFe = cl.getFeaturesFraction(clB).iterator();
    319                         while(itFe.hasNext()) {
    320                                 double rt = itFe.next().rt;
    321                                 stB.setValue(rt);
    322                         }
    323                        
    324                         stA.compute();
    325                         stB.compute();
    326                        
    327                         stA.getMean();
    328                         stB.getMean();
    329                        
    330                         //Adding random value to avoid duplico's
    331                         double random = Math.random() * 0.0001;
    332                        
    333                         xySC.add(stA.getMean() + random, stB.getMean(), cl);
    334                 }
    335                
    336                
    337                 xySC.sort(); //Sorts on X values;
    338                 double[] aValues = xySC.getXVals();
    339                 double[] bValues = xySC.getYVals();
    340                 Cluster[] clusters = xySC.getClusters();
    341                
    342                 double[] bCorrected = null;
    343                
    344                 System.out.println("a0: " + aValues[0] + " b0: " + bValues[0] );
    345                 System.out.println("a1: " + aValues[1] + " b1: " + bValues[1] );
    346                 System.out.println("a2: " + aValues[2] + " b2: " + bValues[2] );
    347                 System.out.println("a3: " + aValues[3] + " b3: " + bValues[3] );
    348                 System.out.println("a4: " + aValues[4] + " b4: " + bValues[4] );
    349                
    350                
    351                 LoessInterpolator lip = new LoessInterpolator();
    352                 try {
    353                         bCorrected = lip.smooth(aValues, bValues);
    354                 } catch (MathException e) {
    355                         // TODO Auto-generated catch block
    356                         e.printStackTrace();
    357                 }
    358                
    359                 System.out.println("a0: " + aValues[0] + " b0: " + bValues[0] + "y0: " + bCorrected[0] );
    360                 System.out.println("a1: " + aValues[1] + " b1: " + bValues[1] + "y1: " + bCorrected[1] );
    361                 System.out.println("a2: " + aValues[2] + " b2: " + bValues[2] + "y2: " + bCorrected[2] );
    362                 System.out.println("a3: " + aValues[3] + " b3: " + bValues[3] + "y3: " + bCorrected[3] );
    363                 System.out.println("a4: " + aValues[4] + " b4: " + bValues[4] + "y4: " + bCorrected[4] );
    364                
    365                
    366                 for(int a = 0; a < bCorrected.length; a++) {
    367                         if(Math.abs(bCorrected[a] - bValues[a]) < 1) {
    368                                 result.add(clusters[a]);
    369                         }
    370                 }
    371                
     311
     312                        Set<Integer> frNums = cl.getFractionNums();
     313                       
     314                        Iterator<Integer> itFrNum = frNums.iterator();
     315                       
     316                        if(frNums.size() == 2) {
     317                               
     318                                Integer frANum = itFrNum.next();
     319                                Integer frBNum = itFrNum.next();
     320                               
     321                                Integer SizeA = cl.getFeaturesFraction(frANum).size();
     322                                Integer SizeB = cl.getFeaturesFraction(frBNum).size();
     323
     324                                double ratioA = (double)SizeA / (double)(maxSamplesPerClass.get(frANum));
     325                                double ratioB = (double)SizeB / (double)(maxSamplesPerClass.get(frBNum));
     326                               
     327                                if(SizeA > 0 && SizeB > 0 && (ratioA >= postProcessThreshold || ratioB >= postProcessThreshold)) {
     328                                        result.add(cl.clone());
     329                                } // else {
     330//                                      System.out.println("postThreshold: " + postProcessThreshold + " size A: " + SizeA + " size B: " + SizeB + " ratio A: " + ratioA + " sum maxSamples: " + (maxSamplesPerClass.get(frANum) + maxSamplesPerClass.get(frBNum)));
     331//                              }
     332                        } else {
     333                                System.out.println("Too Many Classes " + frNums.size());
     334                        }
     335                       
     336                }
     337
    372338                return result;
    373339        }
    374340
    375         private ArrayList<Cluster> filterAllClusters(ArrayList<Cluster> allClusters) {
     341        private void saveOverlappingPeaks(Parameters param, ArrayList<MatchedPeak> mpList, String fileName) {
     342                Iterator<String> itInput;
     343               
     344                String ipFile = param.getInputFiles().getInputFiles().iterator().next();
     345                File otFile = new File(param.getInputFiles().getOutputFileForInputFile(ipFile));
     346               
     347                String outputFileName =  otFile.getParent() + File.separator + fileName;
     348               
     349                //Add to the peakMatrix!! (for debug only atm ...)
     350                PeakMatrix peakMatrixResult = new PeakMatrix();
     351                peakMatrixResult.addMatchedPeaks(mpList);
     352       
     353                itInput = param.getInputFiles().getInputFiles().iterator();
     354                while(itInput.hasNext()) {
     355                        String inputFile = itInput.next();             
     356                        Integer clNum = param.getInputFiles().getClassNumberForInputFile(inputFile);
     357               
     358                        peakMatrixResult.addFileClassPair(inputFile, clNum);
     359                }
     360       
     361                AbstractSavePeakMatrix aspm = new SavePeakMatrixXML();
     362                aspm.savePeakMatrix(outputFileName, peakMatrixResult, null);
     363               
     364                additionalFiles.add(outputFileName);
     365        }
     366               
     367        private ArrayList<Cluster> fitClusters(ArrayList<Cluster> filteredClusters, HashMap<Integer,Integer> pairs, Parameters param) {
     368               
     369                ArrayList<Cluster> result = new ArrayList<Cluster>();
     370               
     371                Set<Integer> key = pairs.keySet();
     372                Iterator<Integer> itFN = key.iterator();
     373                while(itFN.hasNext()) {
     374                        Integer fracNumA = itFN.next();
     375                        Integer fracNumB = pairs.get(fracNumA);
     376                               
     377                        XYCSerie xySC = new XYCSerie();
     378                       
     379                        //Make fractA rt and fractB rt and cluster in one series!!
     380                        ListIterator<Cluster> itCl = filteredClusters.listIterator();
     381                        while(itCl.hasNext()) {
     382                                Cluster cl = itCl.next();
     383                               
     384                                HashSet<Integer> clFracNums = cl.getFractionNums();
     385                                if(clFracNums.contains(fracNumA) && clFracNums.contains(fracNumB)) {
     386                               
     387                                        StatsNormal stA = new StatsNormal();
     388                                        StatsNormal stB = new StatsNormal();
     389                                       
     390                                        Iterator<FeaturePosition> itFe = cl.getFeaturesFraction(fracNumA).iterator();
     391                                        while(itFe.hasNext()) {
     392                                                double rt = itFe.next().rt;
     393                                                stA.setValue(rt);
     394                                        }
     395                                       
     396                                        itFe = cl.getFeaturesFraction(fracNumB).iterator();
     397                                        while(itFe.hasNext()) {
     398                                                double rt = itFe.next().rt;
     399                                                stB.setValue(rt);
     400                                        }
     401                                       
     402                                        stA.compute();
     403                                        stB.compute();
     404                                       
     405                                        stA.getMean();
     406                                        stB.getMean();
     407                                       
     408                                        //Adding random value to avoid duplico's
     409                                        double random = Math.random() * 0.0001;
     410                                       
     411                                        if( Double.isInfinite(stA.getMean()) || Double.isNaN(stA.getMean()) ||
     412                                                Double.isInfinite(stB.getMean()) || Double.isNaN(stB.getMean())) {
     413                                               
     414                                                System.out.println("Invalid cluser: ( mean rt(A): " + stA.getMean() + " mean rt(B): " + stB.getMean() + " )");
     415                                                System.out.println(cl);
     416                                               
     417                                        } else {
     418                                                xySC.add(stA.getMean() + random, stB.getMean(), cl);
     419                                        }               
     420                                }
     421                        }
     422                       
     423                        xySC.sort(); //Sorts on X values;
     424                        double[] aValues = xySC.getXVals();
     425                        double[] bValues = xySC.getYVals();
     426                        Cluster[] clusters = xySC.getClusters();
     427                       
     428                        clusters[0].getSize();
     429                       
     430                        double[] bCorrected = null;
     431                       
     432                        System.out.println("a0: " + aValues[0] + " b0: " + bValues[0] );
     433                        System.out.println("a1: " + aValues[1] + " b1: " + bValues[1] );
     434                        System.out.println("a2: " + aValues[2] + " b2: " + bValues[2] );
     435                        System.out.println("a3: " + aValues[3] + " b3: " + bValues[3] );
     436                        System.out.println("a4: " + aValues[4] + " b4: " + bValues[4] );
     437
     438                        //Get User Settings
     439                       
     440                        Double fitBandWidth = param.getParameters().getAttributeDoubleValue(loessBaundWidth);
     441                        Integer fitIterations = param.getParameters().getAttributeIntegerValue(loessIterations);
     442                       
     443                        if(fitBandWidth == null) {
     444                                fitBandWidth = LoessInterpolator.DEFAULT_BANDWIDTH;
     445                        }
     446                        if(fitIterations == null) {
     447                                fitIterations = LoessInterpolator.DEFAULT_ROBUSTNESS_ITERS;
     448                        }
     449                       
     450                        //Apply LOESS Fitting of the data.
     451                        try {
     452                                LoessInterpolator lip = new LoessInterpolator(fitBandWidth, fitIterations);
     453                                bCorrected = lip.smooth(aValues, bValues);
     454                        } catch (MathException e) {
     455                                e.printStackTrace();
     456                        }
     457                       
     458                        System.out.println("a0: " + aValues[0] + " b0: " + bValues[0] + "y0: " + bCorrected[0] );
     459                        System.out.println("a1: " + aValues[1] + " b1: " + bValues[1] + "y1: " + bCorrected[1] );
     460                        System.out.println("a2: " + aValues[2] + " b2: " + bValues[2] + "y2: " + bCorrected[2] );
     461                        System.out.println("a3: " + aValues[3] + " b3: " + bValues[3] + "y3: " + bCorrected[3] );
     462                        System.out.println("a4: " + aValues[4] + " b4: " + bValues[4] + "y4: " + bCorrected[4] );
     463                       
     464                       
     465                        double maxFitDistance = param.getParameters().getAttributeDoubleValue(maxDistanceFromFit);
     466                                               
     467                        for(int a = 0; a < bCorrected.length; a++) {
     468                                if(Math.abs(bCorrected[a] - bValues[a]) < maxFitDistance) {
     469                                        result.add(clusters[a]);
     470                                }
     471                        }
     472                       
     473                }               
     474               
     475                return result;
     476        }
     477
     478        private ArrayList<Cluster> filterDuplicateClusters(ArrayList<Cluster> allClusters) {
    376479
    377480        ArrayList<Cluster> inputClusters = new ArrayList<Cluster>();
     
    594697                }
    595698               
    596                
     699                /**
     700                 * Returns the number of featurePositions Included in this cluster
     701                 */
     702                public Integer getSize() {
     703                        return cluster.size();                 
     704                }
     705
     706
    597707                public FeaturePosition getFeaturesByFilename(String fileName) {
    598708                        FeaturePosition result = null;
     
    644754                }
    645755               
     756                @Override
    646757                public Cluster clone() {
    647758                        Cluster result = new Cluster();
     
    650761                                result.add(itFe.next().clone());
    651762                        }
     763                        return result;
     764                }
     765               
     766                @Override
     767                public String toString() {
     768                       
     769                        String result = "";
     770                       
     771                        Iterator<FeaturePosition> itFe = cluster.iterator();
     772                        while(itFe.hasNext()) {
     773                                FeaturePosition fp = itFe.next();
     774                               
     775                                result = result + "======= Feature Position =======\n";
     776                                result = result + "rt:          " + fp.rt + "\n";
     777                                result = result + "mz:          " + fp.mz + "\n";
     778                                result = result + "classNum:    " + fp.classNum + "\n";
     779                                result = result + "fractionNum: " + fp.fractionNum + "\n";
     780                                result = result + "fileName:    " + fp.fileName + "\n";
     781                               
     782                        }
     783                       
    652784                        return result;
    653785                }
  • /trunk/msCompare/src/saveData/peakMatrix/SaveAPMLPeakMatrix.java

    r20 r30  
    99import javax.xml.stream.XMLStreamException;
    1010
    11 import org.apache.xmlbeans.XmlCalendar;
    1211import org.apache.xmlbeans.XmlException;
    1312import org.systemsbiology.apmlparser.v2.APMLWriter;
     
    3635                save(fileName,peakMatrix);     
    3736        }
     37       
     38        private String getStrippedFileName(String fName) {
     39                String result = "";
     40               
     41                //Get only the name not the path as well
     42                result = (new File(fName)).getName();
     43               
     44                //Remove extension!!
     45                if(result.contains(".")) {
     46                        result = result.substring(0, result.indexOf("."));
     47                }
     48               
     49                return result;
     50        }
    3851
    3952        private void save(String fileName, PeakMatrix peakMatrix) {
     
    5063                        String fName = itNames.next();
    5164                       
    52                         //Get only the name not the path as well
    53                         fName = (new File(fName)).getName();
     65                        fName = getStrippedFileName(fName);
    5466                       
    5567                        FeatureSource fs = new FeatureSource(fName);
     
    199211                }
    200212               
    201                 fe.setSource(MatchedPeak.getInputFile(pg));
     213                //Gets the striped Feature Name
     214                String sourceFile = getStrippedFileName(MatchedPeak.getInputFile(pg));
     215               
     216                fe.setSource(sourceFile);
    202217                fe.setCoord(coord);
    203218                fe.setId(id);
  • /trunk/msCompare/src/saveData/peakMatrix/SavePeakMatrixTab.java

    r20 r30  
    1616import dataStructures.misc.TabExport;
    1717import dataStructures.misc.TabExportNode;
     18import dataStructures.misc.helpers.TabExportFunctions;
    1819import dataStructures.peakMatrix.MatchedPeak;
    1920import dataStructures.peakMatrix.PeakMatrix;
     
    6465                                        ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationSum)) {
    6566                                       
    66                                         Double value = getDirectCalc(ten,mp);
     67                                        Double value = TabExportFunctions.getDirectCalc(ten,mp);
    6768                                        if(value != null) {
    6869                                                line += value.toString() + "\t";
     
    7172                                        }
    7273                                } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationUnique)) {
    73                                         Set<Object> uniqueVals = getDirectUnique(ten,mp);
     74                                        Set<Object> uniqueVals = TabExportFunctions.getDirectUnique(ten,mp);
    7475                                        line += getUniqueValsString(uniqueVals) + "\t";                                 
    7576                                } else {
     
    9899                                                ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationSum)) {
    99100                                               
    100                                                 Double value = getPerSampleCalc(ten,mp,fName);
     101                                                Double value = TabExportFunctions.getPerSampleCalc(ten,mp,fName);
    101102                                                if(value != null) {
    102103                                                        line += value.toString() + "\t";
     
    105106                                                }
    106107                                        } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationUnique)) {
    107                                                 Set<Object> uniqueVals = getPerSampleUnique(ten,mp,fName);
     108                                                Set<Object> uniqueVals = TabExportFunctions.getPerSampleUnique(ten,mp,fName);
    108109                                                line += getUniqueValsString(uniqueVals) + "\t";                                 
    109110                                        } else {
     
    125126                write.close();
    126127        }
    127 
    128        
    129         private Set<Object> getPerSampleUnique(TabExportNode ten, MatchedPeak mp, String fileName) {
    130                 Set<Object> uniqueVals = new HashSet<Object>();
    131                
    132                 HashMap<String,ArrayList<PeakAttribute>> paMap = mp.getPeakAttributes(ten.getAttributeName(), ten.getProgramName());
    133 
    134                 ArrayList<PeakAttribute> peakAttributes = paMap.get(fileName);
    135                 if(peakAttributes != null) {           
    136                         Iterator<PeakAttribute> itPA = peakAttributes.iterator();
    137                         while(itPA.hasNext()) {
    138                                 PeakAttribute pa = itPA.next();
    139                                 uniqueVals.add(pa.getValue());
    140                         }
    141                 }
    142                                
    143                 return uniqueVals;
    144         }
    145128       
    146129        private String getUniqueValsString(Set<Object> uniqueVals) {
     
    156139               
    157140                return result;
    158         }
    159 
    160         private Double getPerSampleCalc(TabExportNode ten, MatchedPeak mp, String fileName) {
    161                
    162                 Double result = null;
    163                 StatsNormal sn = new StatsNormal();
    164 
    165                 HashMap<String,ArrayList<PeakAttribute>> paMap = mp.getPeakAttributes(ten.getAttributeName(), ten.getProgramName());
    166 
    167                 ArrayList<PeakAttribute> peakAttributes = paMap.get(fileName);
    168                 if(peakAttributes != null) {
    169                         Iterator<PeakAttribute> itPA = peakAttributes.iterator();
    170                         while(itPA.hasNext()) {
    171                                 PeakAttribute pa = itPA.next();
    172                                 Double temp = pa.getDoubleValue();
    173                                 if(temp != null) {
    174                                         sn.setValue(temp);
    175                                 } else {
    176                                         //TODO give an error!!
    177                                 }
    178                         }
    179                        
    180                         sn.compute();
    181                        
    182                         if(ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationAverage)) {
    183                                 double value = sn.getMean();
    184                                 result = ((Double)value);
    185                         } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationStdev)) {
    186                                 double value = sn.getStdev();
    187                                 result = ((Double)value);
    188                         } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationMax)) {
    189                                 double value = sn.getMax();
    190                                 result = ((Double)value);
    191                         } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationMin)) {
    192                                 double value = sn.getMin();
    193                                 result = ((Double)value);
    194                         } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationSum)) {
    195                                 double value = sn.getSum();
    196                                 result = ((Double)value);
    197                         }
    198                 }
    199                
    200                 return result;
    201         }
    202 
    203         /**
    204          * Returns the average value
    205          *
    206          * @param ten
    207          * @param mp
    208          * @return
    209          */
    210         private Double getDirectCalc(TabExportNode ten, MatchedPeak mp) {
    211                
    212                 Double result = null;
    213                 StatsNormal sn = new StatsNormal();
    214                
    215                 HashMap<String,ArrayList<PeakAttribute>> paMap = mp.getPeakAttributes(ten.getAttributeName(), ten.getProgramName());
    216                 Iterator<String> inputFiles = paMap.keySet().iterator();
    217                 while(inputFiles.hasNext()) {
    218                         String inputFile = inputFiles.next();
    219                        
    220                         ArrayList<PeakAttribute> peakAttributes = paMap.get(inputFile);
    221                         Iterator<PeakAttribute> itPA = peakAttributes.iterator();
    222                         while(itPA.hasNext()) {
    223                                 PeakAttribute pa = itPA.next();
    224                                 Double temp = pa.getDoubleValue();
    225                                 if(temp != null) {
    226                                         sn.setValue(temp);
    227                                 } else {
    228                                         //TODO give an error!!
    229                                 }
    230                         }
    231                 }
    232                
    233                 sn.compute();
    234                
    235                 if(ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationAverage)) {
    236                         double value = sn.getMean();
    237                         result = ((Double)value);
    238                 } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationStdev)) {
    239                         double value = sn.getStdev();
    240                         result = ((Double)value);
    241                 } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationMax)) {
    242                         double value = sn.getMax();
    243                         result = ((Double)value);
    244                 } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationMin)) {
    245                         double value = sn.getMin();
    246                         result = ((Double)value);
    247                 } else if (ten.getWriteManipulation().equalsIgnoreCase(TabExportNode.writeManipulationSum)) {
    248                         double value = sn.getSum();
    249                         result = ((Double)value);
    250                 }
    251                
    252                 return result;
    253         }
    254        
    255         /**
    256          * Returns as the field a list of comma separated values.
    257          *
    258          */
    259         private Set<Object> getDirectUnique(TabExportNode ten, MatchedPeak mp) {
    260                
    261                 Set<Object> uniqueVals = new HashSet<Object>();
    262                
    263                 HashMap<String,ArrayList<PeakAttribute>> paMap = mp.getPeakAttributes(ten.getAttributeName(), ten.getProgramName());
    264                 Iterator<String> inputFiles = paMap.keySet().iterator();
    265                 while(inputFiles.hasNext()) {
    266                         String inputFile = inputFiles.next();
    267                        
    268                         ArrayList<PeakAttribute> peakAttributes = paMap.get(inputFile);
    269                         Iterator<PeakAttribute> itPA = peakAttributes.iterator();
    270                         while(itPA.hasNext()) {
    271                                 PeakAttribute pa = itPA.next();
    272                                 uniqueVals.add(pa.getValue().toString());
    273                         }
    274                 }
    275                
    276                 return uniqueVals;
    277         }
    278        
     141        }       
    279142       
    280143//      // Just to index the whole thing, didn't count if some exist twice with in the same fileName
Note: See TracChangeset for help on using the changeset viewer.