示例#1
0
 public ScoreModelUnit(SpecificFragment specificFragment, double intensityMax, double probability, double probabilityNoise)
 {
     FragmentationMode   = specificFragment.FragmentationMode;
     FragmentationType   = specificFragment.FragmentationType;
     FragmentDescription = specificFragment.FragmentDescription;
     LipidClass          = specificFragment.LipidClass;
     LipidType           = specificFragment.LipidType;
     IntensityMax        = intensityMax;
     Probability         = probability;
     ProbabilityNoise    = probabilityNoise;
 }
示例#2
0
        public ScoreModel CreateScoreModel(double hcdError, double cidError)
        {
            const int numTopHitsToConsider = 1;

            var observationDictionary = new Dictionary <SpecificFragment, List <double> >();

            foreach (var datasetLocation in DatasetLocations)
            {
                // Setup workflow
                var globalWorkflow = new GlobalWorkflow(datasetLocation);

                // Run workflow
                var lipidGroupSearchResults = globalWorkflow.RunGlobalWorkflow(LipidList, 30, 500);

                // Group results of same scan together
                var resultsGroupedByScan = lipidGroupSearchResults.GroupBy(x => x.SpectrumSearchResult.HcdSpectrum.ScanNum);

                // Grab the result(s) with the best score
                foreach (var group in resultsGroupedByScan)
                {
                    var groupOrdered = group.OrderByDescending(x => x.SpectrumSearchResult.Score).ToList();

                    for (var i = 0; i < numTopHitsToConsider && i < groupOrdered.Count; i++)
                    {
                        var resultToAdd = groupOrdered[i];

                        var lipidTarget          = resultToAdd.LipidTarget;
                        var lipidClass           = lipidTarget.LipidClass;
                        var lipidType            = lipidTarget.LipidType;
                        var fragmentationMode    = lipidTarget.FragmentationMode;
                        var spectrumSearchResult = resultToAdd.SpectrumSearchResult;
                        var cidResultList        = spectrumSearchResult.CidSearchResultList;
                        var hcdResultList        = spectrumSearchResult.HcdSearchResultList;

                        var cidMaxValue = spectrumSearchResult.CidSpectrum.Peaks.Any() ? spectrumSearchResult.CidSpectrum.Peaks.Max(x => x.Intensity) : 1;
                        var hcdMaxValue = spectrumSearchResult.HcdSpectrum.Peaks.Any() ? spectrumSearchResult.HcdSpectrum.Peaks.Max(x => x.Intensity) : 1;

                        // CID Results
                        foreach (var cidResult in cidResultList)
                        {
                            var    fragment  = cidResult.TheoreticalPeak.Description;
                            double intensity = 0;

                            if (cidResult.ObservedPeak != null)
                            {
                                intensity = Math.Log10(cidResult.ObservedPeak.Intensity) / Math.Log10(cidMaxValue);
                            }

                            var specificFragment = new SpecificFragment(lipidClass, lipidType, fragment, fragmentationMode, FragmentationType.CID);

                            // Either update the observation list or create a new one
                            List <double> observationList;
                            if (observationDictionary.TryGetValue(specificFragment, out observationList))
                            {
                                observationList.Add(intensity);
                            }
                            else
                            {
                                observationList = new List <double> {
                                    intensity
                                };
                                observationDictionary.Add(specificFragment, observationList);
                            }
                        }

                        // HCD Results
                        foreach (var hcdResult in hcdResultList)
                        {
                            var    fragment  = hcdResult.TheoreticalPeak.Description;
                            double intensity = 0;

                            if (hcdResult.ObservedPeak != null)
                            {
                                intensity = Math.Log10(hcdResult.ObservedPeak.Intensity) / Math.Log10(hcdMaxValue);
                            }

                            var specificFragment = new SpecificFragment(lipidClass, lipidType, fragment, fragmentationMode, FragmentationType.HCD);

                            // Either update the observation list or create a new one
                            List <double> observationList;
                            if (observationDictionary.TryGetValue(specificFragment, out observationList))
                            {
                                observationList.Add(intensity);
                            }
                            else
                            {
                                observationList = new List <double> {
                                    intensity
                                };
                                observationDictionary.Add(specificFragment, observationList);
                            }
                        }
                    }
                }

                // Assure that the source data file is closed
                globalWorkflow.LcMsRun.Close();
            }

            var liquidScoreModelUnitList = PartitionIntoModelUnits(observationDictionary);
            var liquidScoreModel         = new ScoreModel(liquidScoreModelUnitList);

            return(liquidScoreModel);
        }