Пример #1
0
        /// <summary>
        /// Extract isomer ratios from a given spectrum (transformed into capacity vector)
        /// </summary>
        /// <param name="ratiosToFit"></param>
        /// <param name="nbProductsToKeep"></param>
        /// <param name="capacity"></param>
        /// <param name="tolerance"></param>
        /// <param name="PrecursorIntensityInCTrap"></param>
        /// <param name="PrecursorIntensity"></param>
        /// <param name="underFlow"></param>
        /// <param name="percentError"></param>
        /// <param name="ConSole"></param>
        /// <returns></returns>
        public static Dictionary <CharacterizedPrecursor, SolvedResult> SolveFromSpectrum(IEnumerable <CharacterizedPrecursor> ratiosToFit, int nbProductsToKeep,
                                                                                          IEnumerable <MsMsPeak> capacity, MassTolerance tolerance,
                                                                                          double PrecursorIntensityInCTrap, double PrecursorIntensity,
                                                                                          out double underFlow, out double percentError, IConSol ConSole, string fileOut = null)
        {
            bool keepGoing = true;
            Dictionary <double, double>         mixedSpectrum = new Dictionary <double, double>();
            List <Dictionary <double, double> > unitSpectrum  = new List <Dictionary <double, double> >();

            foreach (CharacterizedPrecursor isomer in ratiosToFit)
            {
                foreach (double key in isomer.NormalizedFragments[nbProductsToKeep].Keys)
                {
                    if (!mixedSpectrum.ContainsKey(key))
                    {
                        double cumulIntensity = 0.0;
                        foreach (MsMsPeak peak in capacity)
                        {
                            if (Math.Abs(Utilities.Numerics.CalculateMassError(peak.MZ, key, tolerance.Units)) <= tolerance.Value)
                            {
                                cumulIntensity += peak.Intensity;
                            }
                        }

                        mixedSpectrum.Add(key, cumulIntensity);// / PrecursorIntensityInCTrap);
                    }
                }
                if (isomer.NormalizedFragments.ContainsKey(nbProductsToKeep))
                {
                    if (isomer.FragmentNormalizor.ContainsKey(nbProductsToKeep))
                    {
                        Dictionary <double, double> dic = new Dictionary <double, double>();
                        foreach (double key in isomer.NormalizedFragments[nbProductsToKeep].Keys)
                        {
                            dic.Add(key, isomer.NormalizedFragments[nbProductsToKeep][key] *
                                    isomer.FragmentNormalizor[nbProductsToKeep].InterpolateIntensity(PrecursorIntensityInCTrap));
                        }
                        unitSpectrum.Add(dic);
                    }
                    else
                    {
                        unitSpectrum.Add(isomer.NormalizedFragments[nbProductsToKeep]);
                    }
                }
                else
                {
                    keepGoing = false;
                }
            }
            vsCSVWriter writerFrag = null;

            if (!string.IsNullOrEmpty(fileOut))
            {
                writerFrag = new vsCSVWriter(fileOut);
                string line = "Fragments:";
                foreach (double key in mixedSpectrum.Keys)
                {
                    line += "," + key;
                }
                writerFrag.AddLine(line);

                line = "Mixed:";
                foreach (double val in mixedSpectrum.Values)
                {
                    line += "," + val;
                }
                writerFrag.AddLine(line);
            }

            //This nbProduct seems relevant, try to use isomer to get ratios for this spectrum
            if (keepGoing)
            {
                List <double> solution = new List <double>();
                double        stepSize = PrecursorIntensityInCTrap / 1000.0;
                if (stepSize < 1)
                {
                    stepSize = 1;
                }
                double tmpUnderflow = 0;
                Utilities.Methods.GradientDescent.SolveMaxFlowStyle(unitSpectrum, mixedSpectrum, out solution, out tmpUnderflow, ConSole, stepSize);
                //Utilities.Methods.GradientDescent.SolveFromGradientDescent(unitSpectrum, mixedSpectrum, PrecursorIntensityInCTrap, out solution, out tmpUnderflow, ConSole);

                double sumOfIntensities = 0;
                foreach (double val in mixedSpectrum.Values)
                {
                    sumOfIntensities += val;
                }

                underFlow = tmpUnderflow;
                List <SolvedResult> result = GetResultList(solution, underFlow, sumOfIntensities);

                Dictionary <CharacterizedPrecursor, SolvedResult> resultPerSample = new Dictionary <CharacterizedPrecursor, SolvedResult>();
                int i = 0;
                foreach (CharacterizedPrecursor key in ratiosToFit)
                {
                    resultPerSample.Add(key, result[i]);
                    i++;
                }

                if (writerFrag != null)
                {
                    foreach (CharacterizedPrecursor cPrec in ratiosToFit)
                    {
                        string line = cPrec.Peptide.Sequence;
                        foreach (double key in mixedSpectrum.Keys)
                        {
                            line += "," + cPrec.NormalizedFragments[nbProductsToKeep][key] * resultPerSample[cPrec].NbFitTimes;
                        }
                        writerFrag.AddLine(line);
                    }
                    writerFrag.WriteToFile();
                }

                percentError = (underFlow / sumOfIntensities);
                return(resultPerSample);
            }
            else
            {
                percentError = 1.0;
                underFlow    = 0;
                return(new Dictionary <CharacterizedPrecursor, SolvedResult>());
            }
        }
        /// <summary>
        /// Compares individual items with their respective items from control file.
        /// </summary>
        /// <param name="items">Items to compare.</param>
        /// <param name="sampleToControlMaxFold">Maximum sample to control ratio.</param>
        /// <param name="controlToSampleMaxFold">Maximum control to sample ratio.</param>
        /// <param name="massTolerance">Mass tolerance used for peak consolidation.</param>
        /// <param name="inputFiles">Input files information sorted in the final view order.</param>
        protected override Dictionary <UnknownFeatureIonInstanceItem, Tuple <InControlStatus, double?> > CompareComponentItems(
            List <UnknownFeatureIonInstanceItem> items,
            double sampleToControlMaxFold,
            double controlToSampleMaxFold,
            MassTolerance massTolerance,
            List <InputFileInfo> inputFiles)
        {
            // init results dict
            var results = new Dictionary <UnknownFeatureIonInstanceItem, Tuple <InControlStatus, double?> >();

            // make input files map
            var inputFilesMap = inputFiles.ToDictionary(key => key.FileID);

            // get all control items
            var controlItems = items.Where(w => inputFilesMap[w.FileID].IsReference).ToList();

            // compare all items
            foreach (var item in items)
            {
                // init status and ratio
                InControlStatus status;
                double?         ratio = null;

                // get input file info
                var inputFile = inputFilesMap[item.FileID];

                // control item itself but NOT found
                if (inputFile.IsReference && item.Area.Equals(0))
                {
                    status = InControlStatus.NotInControlSelf;
                    results.Add(item, Tuple.Create(status, ratio));
                    continue;
                }

                // control item itself
                if (inputFile.IsReference)
                {
                    status = InControlStatus.InControlSelf;
                    results.Add(item, Tuple.Create(status, ratio));
                    continue;
                }

                // no control file assigned
                if (inputFile.HasReference == false)
                {
                    status = InControlStatus.NoControlAssigned;
                    results.Add(item, Tuple.Create(status, ratio));
                    continue;
                }

                // get corresponding control item
                double maxDelta    = massTolerance.GetToleranceInU(item.MolecularWeight);
                var    controlItem = controlItems.FirstOrDefault(w => w.FileID == inputFile.ReferenceFileID && Math.Abs(w.MolecularWeight - item.MolecularWeight) <= maxDelta);

                // not found in control
                if (controlItem == null || controlItem.Area.Equals(0))
                {
                    status = InControlStatus.NotInControl;
                    results.Add(item, Tuple.Create(status, ratio));
                    continue;
                }

                // calc sample to control area ratio
                ratio = item.Area / controlItem.Area;

                // get in-control status
                bool inControl = (sampleToControlMaxFold.Equals(0) || ratio <= sampleToControlMaxFold) &&
                                 (controlToSampleMaxFold.Equals(0) || 1.0 / ratio <= controlToSampleMaxFold);

                status = (inControl) ? InControlStatus.InControl : InControlStatus.Outside;

                // store result
                results.Add(item, Tuple.Create(status, ratio));
            }

            return(results);
        }
Пример #3
0
 public FastOverlapDemultiplexer(MsDataFileImpl demuxProcessedFile)
 {
     _dataFile = demuxProcessedFile;
     _dataFile.EnableCaching(200);
     _fragmentTolerance = new MassTolerance(10);
 }
        private static double ComputeMaxFlow(List <List <ProductMatch> > spikedMatches,
                                             List <MsMsPeak> mixedSpectrum, MassTolerance tolerance,
                                             ref List <List <double> > optimalSolutions,
                                             ref double percentError,
                                             ref List <long> average, IConSol ConSole)
        {
            //Create dictionnary of usefull peaks
            Dictionary <float, double> mixedFragDic = new Dictionary <float, double>();

            foreach (List <ProductMatch> fragmentRatio in spikedMatches)
            {
                foreach (ProductMatch match in fragmentRatio)
                {
                    if (!mixedFragDic.ContainsKey((float)match.theoMz))
                    {
                        float closest = -1;
                        foreach (float key in mixedFragDic.Keys)
                        {
                            if (Math.Abs(Utilities.Numerics.CalculateMassError(match.theoMz, key, tolerance.Units)) <= tolerance.Value)
                            {
                                closest = key;
                            }
                        }
                        if (closest > 0)
                        {
                            //ConSole.WriteLine("Potential problem with selected fragment masses ");
                            match.theoMz = closest;
                        }
                        else
                        {
                            mixedFragDic.Add((float)match.theoMz, 0);
                        }
                    }
                }
            }

            //Fill dictionnary with Intensities
            List <float> keys = new List <float>(mixedFragDic.Keys);

            foreach (MsMsPeak peak in mixedSpectrum)
            {
                foreach (float mz in keys)
                {
                    if (Math.Abs(Utilities.Numerics.CalculateMassError(peak.MZ, mz, tolerance.Units)) <= tolerance.Value)
                    {
                        mixedFragDic[mz] += peak.Intensity;
                    }
                }
            }

            List <long> localFlows = new List <long>();

            foreach (List <ProductMatch> fragmentRatio in spikedMatches)
            {
                localFlows.Add(FindLocalMaximumFlow(fragmentRatio, mixedFragDic));
            }

            Dictionary <float, double> virtualSpectrum = BuildVirtualSpectrum(spikedMatches, localFlows, mixedFragDic);
            double overError  = MaxFlowHelper.ComputeOverflow(virtualSpectrum, mixedFragDic);
            double underError = MaxFlowHelper.ComputeUnderflow(virtualSpectrum, mixedFragDic);

            double[] bestIndexes = new double[spikedMatches.Count];

            int         iterSize         = 1;
            double      bestOverallError = double.MaxValue;
            List <long> bestLocalFlows   = new List <long>();
            Random      rnd = new Random();

            while (overError >= 1 && iterSize < 10000)//anything less than 1 is an acceptable solution
            {
                for (int index = 0; index < bestIndexes.Length; index++)
                {
                    bestIndexes[index] = -1;
                }

                for (int i = 0; i < spikedMatches.Count; i++)
                {
                    if (localFlows[i] > 0)
                    {
                        localFlows[i] -= iterSize;

                        virtualSpectrum = BuildVirtualSpectrum(spikedMatches, localFlows, mixedFragDic);
                        double tmpErrorMinus = MaxFlowHelper.ComputeUnderflow(virtualSpectrum, mixedFragDic);
                        double tmpErrorPlus  = MaxFlowHelper.ComputeOverflow(virtualSpectrum, mixedFragDic);

                        double tmpFlowRate = Math.Abs(overError - tmpErrorPlus);
                        double underDiff   = Math.Abs(underError - tmpErrorMinus);
                        if (underDiff >= 1)
                        {
                            tmpFlowRate /= underDiff;
                        }
                        bestIndexes[i] = tmpFlowRate;

                        localFlows[i] += iterSize;
                    }
                }

                //Pick pseudo randomly best index
                double worstFlowRate = 0.0;
                for (int index = 0; index < bestIndexes.Length; index++)
                {
                    if (bestIndexes[index] > worstFlowRate)
                    {
                        worstFlowRate = bestIndexes[index];
                    }
                }

                if (worstFlowRate > 0)
                {
                    int nbMatching = 0;
                    for (int index = 0; index < bestIndexes.Length; index++)
                    {
                        if (bestIndexes[index] >= worstFlowRate)
                        {
                            nbMatching++;
                        }
                    }

                    int iterChoice = rnd.Next(0, nbMatching - 1);
                    int iterNb     = 0;
                    for (int index = 0; index < bestIndexes.Length; index++)
                    {
                        if (bestIndexes[index] >= worstFlowRate)
                        {
                            if (iterChoice == iterNb)
                            {
                                localFlows[index] -= iterSize;
                            }
                            iterNb++;
                        }
                    }
                    iterSize = 1;
                }
                else
                {
                    iterSize++;
                }

                virtualSpectrum = BuildVirtualSpectrum(spikedMatches, localFlows, mixedFragDic);
                overError       = MaxFlowHelper.ComputeOverflow(virtualSpectrum, mixedFragDic);
                underError      = MaxFlowHelper.ComputeUnderflow(virtualSpectrum, mixedFragDic);
                if (overError + underError < bestOverallError)
                {
                    bestLocalFlows   = new List <long>(localFlows);
                    bestOverallError = overError + underError;
                }
            }//End of while overflow > 1
            optimalSolutions.Clear();

            List <double> newList = new List <double>();

            foreach (long localFlow in localFlows)
            {
                newList.Add(localFlow);
            }
            optimalSolutions.Add(newList);

            newList = new List <double>();
            foreach (long localFlow in bestLocalFlows)
            {
                newList.Add(localFlow);
            }
            optimalSolutions.Add(newList);

            //Compute average
            if (bestOverallError < double.MaxValue)
            {
                average.Clear();
                for (int i = 0; i < optimalSolutions[0].Count; i++)
                {
                    double sum = 0.0;
                    foreach (List <double> solution in optimalSolutions)
                    {
                        sum += solution[i];
                    }
                    double avg = sum / (double)optimalSolutions.Count;
                    average.Add((long)avg);
                }
            }

            //Compute expected error in percentage
            double sumOfIntensities = 0;

            foreach (double val in mixedFragDic.Values)
            {
                sumOfIntensities += val;
            }
            percentError = underError / sumOfIntensities;

            virtualSpectrum = BuildVirtualSpectrum(spikedMatches, localFlows, mixedFragDic);

            return(MaxFlowHelper.ComputeUnderflow(virtualSpectrum, mixedFragDic));
        }
        public static Dictionary <CharacterizedPrecursor, SolvedResult> SolveFromSpectrumBKP(IEnumerable <CharacterizedPrecursor> ratiosToFit, int nbProductsToKeep,
                                                                                             long precision, IEnumerable <MsMsPeak> capacity, MassTolerance tolerance,
                                                                                             int returnType,//0 for max flow, 1 for best flow, 2 for average
                                                                                             double PrecursorIntensityInCTrap,
                                                                                             ref double overFlow, ref double underFlow, ref double errorInPercent, IConSol ConSole)
        {
            List <List <double> > solutions        = new List <List <double> >();
            List <long>           average          = new List <long>();
            List <MsMsPeak>       expandedCapacity = new List <MsMsPeak>();
            double sumOfProducts = 0;

            foreach (MsMsPeak peak in capacity)
            {
                double intensityNormed = peak.Intensity / PrecursorIntensityInCTrap;
                expandedCapacity.Add(new MsMsPeak(peak.MZ, intensityNormed * precision, peak.Charge));
                sumOfProducts += peak.Intensity;
            }
            List <List <ProductMatch> > tmpRatiosToFit = new List <List <ProductMatch> >();

            //foreach (List<ProductMatch> list in ratiosToFit.Values)
            foreach (CharacterizedPrecursor prec in ratiosToFit)
            {
                List <ProductMatch> pms = new List <ProductMatch>();
                foreach (ProductMatch pm in prec.Fragments[nbProductsToKeep])
                {
                    ProductMatch newPm = new ProductMatch(pm);
                    newPm.obsIntensity = newPm.normalizedIntensity;// *PrecursorIntensityInCTrap;
                    pms.Add(newPm);
                }
                tmpRatiosToFit.Add(pms);
            }

            double error = ComputeMaxFlow(tmpRatiosToFit, expandedCapacity, tolerance, ref solutions, ref errorInPercent, ref average, ConSole);

            double sumOfIntensities = 0;

            foreach (MsMsPeak peak in expandedCapacity)
            {
                sumOfIntensities += peak.Intensity;
            }

            overFlow  = 0;
            underFlow = error;

            List <SolvedResult> result = null;

            switch (returnType)
            {
            case 0:
                result = GetResultList(solutions[0], precision, underFlow, sumOfIntensities);
                break;

            case 1:
                result = GetResultList(solutions[1], precision, underFlow, sumOfIntensities);
                break;

            case 2:
                List <double> tmpAverage = new List <double>();
                foreach (double val in average)
                {
                    tmpAverage.Add(val);
                }
                result = GetResultList(tmpAverage, precision, underFlow, sumOfIntensities);
                break;
            }
            Dictionary <CharacterizedPrecursor, SolvedResult> resultPerSample = new Dictionary <CharacterizedPrecursor, SolvedResult>();
            int i = 0;

            foreach (CharacterizedPrecursor key in ratiosToFit)
            {
                resultPerSample.Add(key, result[i]);
                i++;
            }
            return(resultPerSample);
        }
        public static Dictionary <PeptideSpectrumMatch, SolvedResult> SolveFromFragmentScore(int nbProductsToKeep,
                                                                                             double precision, IEnumerable <MsMsPeak> capacity, MassTolerance tolerance,
                                                                                             double PrecursorIntensityInCTrap,
                                                                                             Query query,
                                                                                             out double underFlow, out double percentError, IConSol ConSole)
        {
            List <Dictionary <double, double> > unitSpectrum = new List <Dictionary <double, double> >();

            foreach (PeptideSpectrumMatch psm in query.psms)
            {
                double[] arrayFrag = psm.ComputeAACoverage();
                Dictionary <double, double> individualSpectrum = new Dictionary <double, double>();
                for (int i = 0; i < arrayFrag.Length; i++)
                {
                    individualSpectrum.Add(i, arrayFrag[i]);
                }
                unitSpectrum.Add(individualSpectrum);
            }

            Dictionary <double, double> mixedSpectrum = new Dictionary <double, double>();
            string seq = query.psms[0].Peptide.BaseSequence;

            for (int i = 0; i < seq.Length; i++)
            {
                mixedSpectrum.Add(i, precision);
            }


            List <double> solution     = new List <double>();
            double        tmpUnderflow = 0;

            Utilities.Methods.GradientDescent.SolveMaxFlowStyle(unitSpectrum, mixedSpectrum, out solution, out tmpUnderflow, ConSole, 1);

            double sumOfIntensities = 0;

            foreach (double val in mixedSpectrum.Values)
            {
                sumOfIntensities += val;
            }

            underFlow = tmpUnderflow;
            List <SolvedResult> result = GetResultList(solution, precision, underFlow, sumOfIntensities);

            Dictionary <PeptideSpectrumMatch, SolvedResult> resultPerSample = new Dictionary <PeptideSpectrumMatch, SolvedResult>();
            int k = 0;

            foreach (PeptideSpectrumMatch key in query.psms)
            {
                resultPerSample.Add(key, result[k]);
                k++;
            }

            percentError = (underFlow / sumOfIntensities);
            return(resultPerSample);
        }
        public static Dictionary <PeptideSpectrumMatch, SolvedResult> SolveFromFragmentScoreTheoMZ(int nbProductsToKeep,
                                                                                                   double precision, IEnumerable <MsMsPeak> capacity, MassTolerance tolerance,
                                                                                                   double PrecursorIntensityInCTrap,
                                                                                                   Query query,
                                                                                                   out double underFlow, out double percentError, IConSol ConSole)
        {
            List <Dictionary <double, double> > unitSpectrum = new List <Dictionary <double, double> >();

            foreach (PeptideSpectrumMatch psm in query.psms)
            {
                double[] arrayFrag = psm.ComputeAACoverage();
                Dictionary <double, double> individualSpectrum = new Dictionary <double, double>();
                foreach (ProductMatch match in psm.AllProductMatches)
                {
                    if (!individualSpectrum.ContainsKey(match.theoMz))
                    {
                        individualSpectrum.Add(match.theoMz, 0);
                    }

                    double addedFactor = individualSpectrum[match.theoMz];
                    if (match.Fragment == null)
                    {
                        addedFactor += arrayFrag[match.fragmentPos];
                    }
                    else if (match.Fragment.IsReverse)
                    {
                        for (int i = match.fragmentPos - 1; i < arrayFrag.Length; i++)
                        {
                            addedFactor += arrayFrag[i];
                        }
                    }
                    else
                    {
                        for (int i = match.fragmentPos - 1; i >= 0; i--)
                        {
                            addedFactor += arrayFrag[i];
                        }
                    }
                    individualSpectrum[match.theoMz] += addedFactor;
                }
                double sum = 0.0;
                foreach (double val in individualSpectrum.Values)
                {
                    sum += val;
                }
                foreach (double key in new List <double>(individualSpectrum.Keys))
                {
                    individualSpectrum[key] /= sum;
                }

                unitSpectrum.Add(individualSpectrum);
            }

            Dictionary <double, double> mixedSpectrum = new Dictionary <double, double>();

            foreach (Dictionary <double, double> dic in unitSpectrum)
            {
                foreach (double key in dic.Keys)
                {
                    if (!mixedSpectrum.ContainsKey(key))
                    {
                        mixedSpectrum.Add(key, precision);
                    }
                }
            }
            double nbKeys = (double)mixedSpectrum.Count;

            foreach (double key in new List <double>(mixedSpectrum.Keys))
            {
                mixedSpectrum[key] /= nbKeys;
            }
            //string seq = query.psms[0].Peptide.BaseSequence;
            //for (int i = 0; i < seq.Length; i++)
            //    mixedSpectrum.Add(i, precision);


            List <double> solution     = new List <double>();
            double        tmpUnderflow = 0;

            Utilities.Methods.GradientDescent.SolveMaxFlowStyle(unitSpectrum, mixedSpectrum, out solution, out tmpUnderflow, ConSole, 1);

            double sumOfIntensities = 0;

            foreach (double val in mixedSpectrum.Values)
            {
                sumOfIntensities += val;
            }

            underFlow = tmpUnderflow;
            List <SolvedResult> result = GetResultList(solution, precision, underFlow, sumOfIntensities);

            Dictionary <PeptideSpectrumMatch, SolvedResult> resultPerSample = new Dictionary <PeptideSpectrumMatch, SolvedResult>();
            int k = 0;

            foreach (PeptideSpectrumMatch key in query.psms)
            {
                resultPerSample.Add(key, result[k]);
                k++;
            }

            percentError = (underFlow / sumOfIntensities);
            return(resultPerSample);
        }
Пример #8
0
        public static Dictionary <CharacterizedPrecursor, SolvedResult> SolveFromSpectrum(IEnumerable <CharacterizedPrecursor> ratiosToFit, int nbProductsToKeep,
                                                                                          double precision, IEnumerable <MsMsPeak> capacity, MassTolerance tolerance,
                                                                                          double PrecursorIntensityInCTrap,
                                                                                          out double underFlow, out double percentError, IConSol ConSole)
        {
            bool keepGoing = true;
            Dictionary <double, double>         mixedSpectrum = new Dictionary <double, double>();
            List <Dictionary <double, double> > unitSpectrum  = new List <Dictionary <double, double> >();

            foreach (CharacterizedPrecursor isomer in ratiosToFit)
            {
                foreach (double key in isomer.NormalizedFragments[nbProductsToKeep].Keys)
                {
                    if (!mixedSpectrum.ContainsKey(key))
                    {
                        double cumulIntensity = 0.0;
                        foreach (MsMsPeak peak in capacity)
                        {
                            if (Math.Abs(Proteomics.Utilities.Numerics.CalculateMassError(peak.MZ, key, tolerance.Units)) <= tolerance.Value)
                            {
                                cumulIntensity += peak.Intensity;
                            }
                        }

                        mixedSpectrum.Add(key, cumulIntensity * precision / PrecursorIntensityInCTrap);
                    }
                }
                if (isomer.NormalizedFragments.ContainsKey(nbProductsToKeep))
                {
                    unitSpectrum.Add(isomer.NormalizedFragments[nbProductsToKeep]);
                }
                else
                {
                    keepGoing = false;
                }
            }

            if (keepGoing)
            {
                List <double> solution     = new List <double>();
                double        tmpUnderflow = 0;
                Proteomics.Utilities.Methods.GradientDescent.SolveMaxFlowStyle(unitSpectrum, mixedSpectrum, out solution, out tmpUnderflow, ConSole);

                double sumOfIntensities = 0;
                foreach (double val in mixedSpectrum.Values)
                {
                    sumOfIntensities += val;
                }

                underFlow = tmpUnderflow;
                List <SolvedResult> result = GetResultList(solution, precision, underFlow, sumOfIntensities);

                Dictionary <CharacterizedPrecursor, SolvedResult> resultPerSample = new Dictionary <CharacterizedPrecursor, SolvedResult>();
                int i = 0;
                foreach (CharacterizedPrecursor key in ratiosToFit)
                {
                    resultPerSample.Add(key, result[i]);
                    i++;
                }

                percentError = (underFlow / sumOfIntensities);
                return(resultPerSample);
            }
            else
            {
                percentError = 1.0;
                underFlow    = 0;
                return(new Dictionary <CharacterizedPrecursor, SolvedResult>());
            }
        }