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);
}