public void DisplayComparisonFigure( string pathX, int scanX, string pathY, int scanY, double mzTolerance) { // Convert relative paths to absolute paths pathX = GetPath(pathX); pathY = GetPath(pathY); var spectrumX = GetSpectrum(pathX, scanX); var spectrumY = GetSpectrum(pathY, scanY); var path = Path.GetDirectoryName(pathX); var pathCompareImage = Path.Combine(path, string.Format("comparison-{0}-{1}.png", scanX, scanY)); spectrumX.Peaks = XYData.Bin(spectrumX.Peaks, 0, 2000, mzTolerance); spectrumY.Peaks = XYData.Bin(spectrumY.Peaks, 0, 2000, mzTolerance); DisplayComparisonPlot(spectrumX, spectrumY, mzTolerance, path = pathCompareImage); }
private MSSpectra ReadSpectrum(string path) { var spectrum = new MSSpectra(); var lines = File.ReadAllLines(path); spectrum.Peaks = new List <XYData>(); foreach (var line in lines) { var data = line.Split('\t'); if (data.Length > 1) { spectrum.Peaks.Add(new XYData(Convert.ToDouble(data[0]), Convert.ToDouble(data[1]))); } } spectrum.Peaks = XYData.Bin(spectrum.Peaks, 0, 2000, .15); return(spectrum); }
public void TestSpectralSimilarityScore( string pathX, int scanX, string pathY, int scanY, SpectralComparison comparerType, SpectraFilters filterType, double percent, double mzTolerance) { // Convert relative paths to absolute paths pathX = GetPath(pathX); pathY = GetPath(pathY); var spectrumX = GetSpectrum(pathX, scanX); var spectrumY = GetSpectrum(pathY, scanY); var comparer = SpectralComparerFactory.CreateSpectraComparer(comparerType, percent); var filter = SpectrumFilterFactory.CreateFilter(filterType); spectrumX.Peaks = filter.Threshold(spectrumX.Peaks, percent); spectrumY.Peaks = filter.Threshold(spectrumY.Peaks, percent); spectrumX.Peaks = XYData.Bin(spectrumX.Peaks, 0, 2000, mzTolerance); spectrumY.Peaks = XYData.Bin(spectrumY.Peaks, 0, 2000, mzTolerance); var value = comparer.CompareSpectra(spectrumX, spectrumY); var path = Path.GetDirectoryName(pathX); var plotTitle = string.Format("comparison-{2}-{3}-{0}-{1}_{4:0.000}", scanX, scanY, comparerType, percent, value); var pathCompareImage = Path.Combine(path, plotTitle + ".png"); DisplayComparisonPlot(spectrumX, spectrumY, mzTolerance, pathCompareImage, plotTitle); }
public static MSSpectra GetSpectra(double mzTolerance, double percent, ISpectraFilter filter, ISpectraProvider readerY, int scany, int numberRequiredPeaks) { var spectrum = GetSpectrum(readerY, scany, 0, mzTolerance); if (spectrum.Peaks.Count < numberRequiredPeaks) { return(null); } spectrum.Peaks = filter.Threshold(spectrum.Peaks, percent); spectrum.Peaks = XYData.Bin(spectrum.Peaks, 0, 2000, mzTolerance); return(spectrum); }
/// <summary> /// Gets the spectral matches /// </summary> /// <param name="baselineFeatures"></param> /// <param name="aligneeFeatures"></param> /// <returns></returns> private List <SpectralMatch> GetSpectralMatches(List <UMCLight> baselineFeatures, List <UMCLight> aligneeFeatures, double comparisonCutoff) { var matches = new List <SpectralMatch>(); var baselineSpectra = GetSpectra(baselineFeatures); var aligneeSpectra = GetSpectra(aligneeFeatures); // Optimizes the loading of a spectra... var map = new Dictionary <int, MSSpectra>(); var filter = SpectrumFilterFactory.CreateFilter(SpectraFilters.TopPercent); var comparer = SpectralComparerFactory.CreateSpectraComparer(SpectralComparison.CosineDotProduct); var percent = .2; var mzTolerance = .5; double maxScanDiff = 1500; foreach (var baselineSpectrum in baselineSpectra) { baselineSpectrum.Peaks = filter.Threshold(baselineSpectrum.Peaks, percent); baselineSpectrum.Peaks = XYData.Bin(baselineSpectrum.Peaks, 0, 2000, mzTolerance); foreach (var aligneeSpectrum in aligneeSpectra) { // Only consider spectra that are near each other in mass. var diff = Math.Abs(baselineSpectrum.PrecursorMz - aligneeSpectrum.PrecursorMz); if (diff >= mzTolerance) { continue; } // Only consider spectra that are within some range of another. var scanDiff = Math.Abs(aligneeSpectrum.Scan - baselineSpectrum.Scan); if (scanDiff > maxScanDiff) { continue; } // Bin and threshold the spectra aligneeSpectrum.Peaks = filter.Threshold(aligneeSpectrum.Peaks, percent); aligneeSpectrum.Peaks = XYData.Bin(aligneeSpectrum.Peaks, 0, 2000, mzTolerance); // Compare the spectra var value = comparer.CompareSpectra(baselineSpectrum, aligneeSpectrum); if (double.IsNaN(value)) { continue; } if (value > comparisonCutoff) { var match = new SpectralMatch(); match.Alignee = aligneeSpectrum; match.Baseline = baselineSpectrum; match.Similarity = value; matches.Add(match); } } } return(matches); }
/// <summary> /// Clusters spectra together based on similarity. /// </summary> /// <param name="start"></param> /// <param name="stop"></param> /// <param name="features"></param> private List <MsmsCluster> Cluster(int start, int stop, List <MSFeatureLight> features, ISpectraProvider provider, double similarityTolerance) { var massTolerance = MassTolerance; // Maps the feature to a cluster ID. var featureMap = new Dictionary <MSFeatureLight, int>(); // Maps the cluster ID to a cluster. var clusterMap = new Dictionary <int, MsmsCluster>(); var clusters = new List <MsmsCluster>(); // Create singleton clusters. var id = 0; for (var i = start; i < stop; i++) { var feature = features[i]; var cluster = new MsmsCluster(); cluster.Id = id++; cluster.MeanScore = 0; cluster.Features.Add(feature); featureMap.Add(feature, cluster.Id); clusterMap.Add(cluster.Id, cluster); } var protonMass = AdductMass; // Then iterate and cluster. for (var i = start; i < stop; i++) { var featureI = features[i]; var clusterI = clusterMap[featureMap[featureI]]; for (var j = i + 1; j < stop; j++) { var featureJ = features[j]; var clusterJ = clusterMap[featureMap[featureJ]]; // Don't cluster the same thing if (clusterI.Id == clusterJ.Id) { continue; } // Don't cluster from the same dataset. Let the linkage algorithm decide if they // belong in the same cluster, and later, go back and determine if the cluster is valid or not. if (featureI.GroupId == featureJ.GroupId) { continue; } // Check the scan difference. If it fits then we are within range. var scanDiff = Math.Abs(featureI.Scan - featureJ.Scan); if (scanDiff <= ScanRange) { // Use the most abundant mass because it had a higher chance of being fragmented. var mzI = (featureI.MassMonoisotopicMostAbundant / featureI.ChargeState) + protonMass; var mzJ = (featureJ.MassMonoisotopicMostAbundant / featureJ.ChargeState) + protonMass; var mzDiff = Math.Abs(mzI - mzJ); if (mzDiff <= MzTolerance) { var scanSummary = new ScanSummary(); if (featureI.MSnSpectra[0].Peaks.Count <= 0) { featureI.MSnSpectra[0].Peaks = provider.GetRawSpectra(featureI.MSnSpectra[0].Scan, featureI.GroupId, out scanSummary); featureI.MSnSpectra[0].Peaks = XYData.Bin(featureI.MSnSpectra[0].Peaks, 0, 2000, MzTolerance); } if (featureJ.MSnSpectra[0].Peaks.Count <= 0) { featureJ.MSnSpectra[0].Peaks = provider.GetRawSpectra(featureJ.MSnSpectra[0].Scan, featureJ.GroupId, out scanSummary); featureJ.MSnSpectra[0].Peaks = XYData.Bin(featureJ.MSnSpectra[0].Peaks, 0, 2000, MzTolerance); } // Compute similarity var score = SpectralComparer.CompareSpectra(featureI.MSnSpectra[0], featureJ.MSnSpectra[0]); if (score >= similarityTolerance) { clusterJ.MeanScore += score; foreach (var xFeature in clusterI.Features) { clusterJ.Features.Add(xFeature); featureMap[xFeature] = clusterJ.Id; clusterMap.Remove(clusterI.Id); } } } } } } clusters.AddRange(clusterMap.Values); for (var i = start; i < stop; i++) { features[i].MSnSpectra[0].Peaks.Clear(); } foreach (var cluster in clusters) { cluster.MeanScore /= (cluster.Features.Count - 1); } return(clusters); }