public void OnSpectrumSearchResultChange(SpectrumSearchResult spectrumSearchResult)
{
CurrentSpectrumSearchResult = spectrumSearchResult;
OnPropertyChanged("CurrentSpectrumSearchResult");
CreateMsMsPlots();
}
public double ScoreLipid(LipidTarget lipidTarget, SpectrumSearchResult spectrumSearchResult)
{
var relatedScoreModelUnits = GetRelatedScoreModelUnits(lipidTarget);
var cidResultList = spectrumSearchResult.CidSearchResultList;
var hcdResultList = spectrumSearchResult.HcdSearchResultList;
var cidMaxIntensity = spectrumSearchResult.CidSpectrum != null && spectrumSearchResult.CidSpectrum.Peaks.Any() ? spectrumSearchResult.CidSpectrum.Peaks.Max(x => x.Intensity) : 1;
var hcdMaxIntensity = spectrumSearchResult.HcdSpectrum != null && spectrumSearchResult.HcdSpectrum.Peaks.Any() ? spectrumSearchResult.HcdSpectrum.Peaks.Max(x => x.Intensity) : 1;
double lipidScore = 0;
if (cidMaxIntensity > 1)
{
// Score CID Results
lipidScore += ScoreSingleFragmentationType(cidResultList, relatedScoreModelUnits, FragmentationType.CID, cidMaxIntensity);
}
if (hcdMaxIntensity > 1)
{
// Score CID Results
lipidScore += ScoreSingleFragmentationType(hcdResultList, relatedScoreModelUnits, FragmentationType.HCD, hcdMaxIntensity);
}
return(lipidScore);
}
/// <summary>
/// Gets the fit score for the given spectrum and chemical formula.
/// </summary>
/// <param name="spectrumResult">Information about spectra and tolerances.</param>
/// <param name="composition">Composition of liquid to find in the spectrum.</param>
/// <returns>The correlation score between the theoretical spectrum and actual.</returns>
public double GetFitScore(SpectrumSearchResult spectrumResult, Composition composition)
{
return(GetFitScore(
spectrumResult.PrecursorSpectrum,
composition,
spectrumResult.PrecursorTolerance));
}
public void OnMsMsSearchResultChange(SpectrumSearchResult spectrumSearchResult)
{
CurrentSpectrumSearchResult = spectrumSearchResult;
CurrentLipidTarget = LipidUtil.CreateLipidTarget((spectrumSearchResult.HcdSpectrum ?? spectrumSearchResult.CidSpectrum).IsolationWindow.IsolationWindowTargetMz, TargetFragmentationMode, TargetAdduct);
OnPropertyChanged("CurrentSpectrumSearchResult");
OnPropertyChanged("CurrentLipidTarget");
}
/// <summary>
/// Get the fit score of Mass -1.
/// </summary>
/// <param name="spectrumResult">Information about spectra and tolerances.</param>
/// <param name="composition">Composition of liquid to find in the spectrum.</param>
/// <returns>The correlation score between the theoretical spectrum and actual.</returns>
public double GetFitMinus1Score(SpectrumSearchResult spectrumResult, Composition composition)
{
var compositionMinus1 = new Composition(composition.C, composition.H - 1, composition.N, composition.O, composition.S, composition.P);
return(GetFitScore(
spectrumResult.PrecursorSpectrum,
compositionMinus1,
spectrumResult.PrecursorTolerance));
}
public void TestPearsonCorrelation(int precursor, string commonName, string composition, Tolerance tolerance)
{
var rawFilePath = @"\\proto-2\UnitTest_Files\Liquid\PearsonCorrelationTests\OMICS_IM102_691_1d_Lipid_pooled_POS_150mm_17Apr15_Polaroid_14-12-16.raw";
var lcmsRun = PbfLcMsRun.GetLcMsRun(rawFilePath);
var spectrum = lcmsRun.GetSpectrum(precursor);
var parsedComposition = Composition.ParseFromPlainString(composition);
var correlationCalculator = new PearsonCorrelationFitUtil();
//var target = new LipidTarget(commonName, LipidClass.DG, FragmentationMode.Positive, parsedComposition, new List<AcylChain>(), Adduct.Hydrogen);
var spectrumSearchResult = new SpectrumSearchResult(null, null, spectrum, null, null, new Xic(), lcmsRun)
{
PrecursorTolerance = tolerance
};
var correlation = correlationCalculator.GetFitScore(spectrumSearchResult, parsedComposition);
Console.WriteLine("The Pearson correlation is: " + correlation);
}
public void OnSpectrumSearchResultChange(SpectrumSearchResult spectrumSearchResult)
{
CurrentSpectrumSearchResult = spectrumSearchResult;
OnPropertyChanged("CurrentSpectrumSearchResult");
OnPropertyChanged("CurrentLipidTarget");
}
public void PearsonCorrelationFileCombiner(string directoryPath)
{
var dirFiles = Directory.GetFiles(directoryPath);
var correlationCalculator = new PearsonCorrelationFitUtil();
var cosineCalculator = new CosineFitUtil();
// Each dictionary corresponds to a dataset, each dictionary key corresponds to the TSV header.
var results = new List <Dictionary <string, List <string> > >();
var headers = new HashSet <string>();
foreach (var pathToResults in dirFiles.Where(path => path.EndsWith(".txt")))
{
var datasetName = Path.GetFileNameWithoutExtension(pathToResults);
var pathToRaw = GetRawFilePath(directoryPath, datasetName);
var rawName = Path.GetFileName(pathToRaw);
if (string.IsNullOrEmpty(pathToRaw))
{
continue;
}
var lcmsRun = PbfLcMsRun.GetLcMsRun(pathToRaw);
var tolerance = new Tolerance(30, ToleranceUnit.Ppm);
using (var reader = new StreamReader(new FileStream(pathToResults, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
results.Add(new Dictionary <string, List <string> >()); // Add dictionary for new dataset.
var datasetResults = results.Last(); // Results for the current dataset.
var lineCount = 0;
var headerToIndex = new Dictionary <string, int>();
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
var pieces = line.Split('\t').ToArray();
if (lineCount++ == 0)
{ // First line
for (var i = 0; i < pieces.Length; i++)
{
var header = pieces[i];
headerToIndex.Add(header, i);
datasetResults.Add(header, new List <string>());
}
datasetResults.Add("Raw File", new List <string>());
datasetResults.Add("Pearson Corr Score", new List <string>());
datasetResults.Add("Pearson Corr M-1 Score", new List <string>());
datasetResults.Add("Cosine Score", new List <string>());
datasetResults.Add("Cosine M-1 Score", new List <string>());
headers.UnionWith(datasetResults.Keys);
continue;
}
var precursor = Convert.ToInt32(pieces[headerToIndex["Precursor Scan"]]);
var commonName = pieces[headerToIndex["Common Name"]];
var adduct = pieces[headerToIndex["Adduct"]];
var spectrum = lcmsRun.GetSpectrum(precursor);
if (spectrum == null)
{
Console.WriteLine("Invalid scan number: {0}", precursor);
continue;
}
var lipid = new Lipid {
AdductFull = adduct, CommonName = commonName
};
var lipidTarget = lipid.CreateLipidTarget();
var spectrumSearchResult = new SpectrumSearchResult(null, null, spectrum, null, null, new Xic(), lcmsRun)
{
PrecursorTolerance = tolerance
};
var pearsonCorrScore = correlationCalculator.GetFitScore(spectrumSearchResult, lipidTarget.Composition);
var pearsonCorrMinus1Score = correlationCalculator.GetFitMinus1Score(spectrumSearchResult, lipidTarget.Composition);
var cosineScore = cosineCalculator.GetFitScore(spectrumSearchResult, lipidTarget.Composition);
var cosineMinus1Score = cosineCalculator.GetFitScore(
spectrumSearchResult,
lipidTarget.Composition);
// Add results to results dictionary.
datasetResults["Raw File"].Add(rawName);
foreach (var header in headerToIndex.Keys)
{
datasetResults[header].Add(pieces[headerToIndex[header]]);
}
datasetResults["Pearson Corr Score"].Add(pearsonCorrScore.ToString());
datasetResults["Pearson Corr M-1 Score"].Add(pearsonCorrMinus1Score.ToString());
datasetResults["Cosine Score"].Add(cosineScore.ToString());
datasetResults["Cosine M-1 Score"].Add(cosineMinus1Score.ToString());
}
}
}
// Write results
var outputFilePath = Path.Combine(directoryPath, "training.tsv");
using (var writer = new StreamWriter(outputFilePath))
{
// Write headers
foreach (var header in headers)
{
writer.Write("{0}\t", header);
}
writer.WriteLine();
// Write data
foreach (var datasetResults in results)
{
var fileLength = datasetResults["Pearson Corr Score"].Count;
for (var i = 0; i < fileLength; i++)
{
foreach (var header in headers)
{
var value = datasetResults.ContainsKey(header) ? datasetResults[header][i] : string.Empty;
writer.Write("{0}\t", value);
}
writer.WriteLine();
}
}
}
}
public void TestPearsonCorrelationWholeFile(string directoryPath)
{
var dirFiles = Directory.GetFiles(directoryPath);
var correlationCalculator = new PearsonCorrelationFitUtil();
foreach (var pathToResults in dirFiles.Where(path => path.EndsWith(".txt")))
{
var datasetName = Path.GetFileNameWithoutExtension(pathToResults);
var pathToRaw = GetRawFilePath(directoryPath, datasetName);
if (string.IsNullOrEmpty(pathToRaw))
{
continue;
}
var lcmsRun = PbfLcMsRun.GetLcMsRun(pathToRaw);
var tolerance = new Tolerance(30, ToleranceUnit.Ppm);
var rawFileName = Path.GetFileName(pathToRaw);
var datasetDirPath = Path.GetDirectoryName(pathToResults);
var outputFileName = string.Format("{0}_training.tsv", datasetName);
var outputPath = Path.Combine(datasetDirPath, outputFileName);
using (var writer = new StreamWriter(outputPath))
using (var reader = new StreamReader(new FileStream(pathToResults, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
var lineCount = 0;
var headerToIndex = new Dictionary <string, int>();
while (!reader.EndOfStream)
{
var line = reader.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
var pieces = line.Split('\t').ToArray();
if (lineCount++ == 0)
{ // First line
writer.Write("Raw File\t");
for (var i = 0; i < pieces.Length; i++)
{
headerToIndex.Add(pieces[i], i);
writer.Write("{0}\t", pieces[i]);
}
writer.WriteLine("Fit Score\tFit M-1 Score");
continue;
}
var precursor = Convert.ToInt32(pieces[headerToIndex["Precursor Scan"]]);
var commonName = pieces[headerToIndex["Common Name"]];
var adduct = pieces[headerToIndex["Adduct"]];
var spectrum = lcmsRun.GetSpectrum(precursor);
if (spectrum == null)
{
Console.WriteLine("Invalid scan number: {0}", precursor);
continue;
}
var lipid = new Lipid {
AdductFull = adduct, CommonName = commonName
};
var lipidTarget = lipid.CreateLipidTarget();
var spectrumSearchResult = new SpectrumSearchResult(null, null, spectrum, null, null, new Xic(), lcmsRun)
{
PrecursorTolerance = tolerance
};
var fitScore = correlationCalculator.GetFitScore(spectrumSearchResult, lipidTarget.Composition);
var fitMinus1Score = correlationCalculator.GetFitMinus1Score(spectrumSearchResult, lipidTarget.Composition);
writer.Write(rawFileName + "\t");
writer.Write(line);
writer.WriteLine("{0}\t{1}", fitScore, fitMinus1Score);
}
}
}
}
public static List <SpectrumSearchResult> RunInformedWorkflow(
LipidTarget target,
LcMsRun lcmsRun,
double hcdMassError,
double cidMassError,
ScoreModel scoreModel = null)
{
IEnumerable <MsMsSearchUnit> msMsSearchUnits = target.GetMsMsSearchUnits();
// I have to subtract an H for the target Ion since InformedProteomics will assume protenated
var targetIon = new Ion(target.Composition - Composition.Hydrogen, 1);
var targetMz = target.MzRounded;
var hcdTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm);
var cidTolerance = new Tolerance(cidMassError, ToleranceUnit.Ppm);
var activationMethodCombination = GlobalWorkflow.FigureOutActivationMethodCombination(lcmsRun);
// Find out which MS/MS scans have a precursor m/z that matches the target
//List<int> matchingMsMsScanNumbers = lcmsRun.GetFragmentationSpectraScanNums(targetIon).ToList();
var matchingMsMsScanNumbers = lcmsRun.GetFragmentationSpectraScanNums(targetMz).ToList();
var spectrumSearchResultList = new List <SpectrumSearchResult>();
for (var i = 0; i + 1 < matchingMsMsScanNumbers.Count; i += 2)
{
var firstScanNumber = matchingMsMsScanNumbers[i];
var secondScanNumber = matchingMsMsScanNumbers[i + 1];
// Scan numbers should be consecutive.
/*
* if (secondScanNumber - firstScanNumber != 1)
* {
* i--;
* continue;
* }
* */
ProductSpectrum firstMsMsSpectrum = null;
ProductSpectrum secondMsMsSpectrum = null;
if (activationMethodCombination == ActivationMethodCombination.CidThenHcd ||
activationMethodCombination == ActivationMethodCombination.HcdThenCid)
{
// Lookup the MS/MS Spectrum
firstMsMsSpectrum = lcmsRun.GetSpectrum(firstScanNumber) as ProductSpectrum;
if (firstMsMsSpectrum == null)
{
continue;
}
// Lookup the MS/MS Spectrum
secondMsMsSpectrum = lcmsRun.GetSpectrum(secondScanNumber) as ProductSpectrum;
if (secondMsMsSpectrum == null)
{
continue;
}
}
else if (activationMethodCombination == ActivationMethodCombination.CidOnly ||
activationMethodCombination == ActivationMethodCombination.HcdOnly)
{
firstMsMsSpectrum = lcmsRun.GetSpectrum(firstScanNumber) as ProductSpectrum;
}
if (firstMsMsSpectrum == null)
{
continue;
}
// Filter MS/MS Spectrum based on mass error
var msMsPrecursorMz = firstMsMsSpectrum.IsolationWindow.IsolationWindowTargetMz;
//if (Math.Abs(msMsPrecursorMz - targetMz) > 0.4) continue;
var ppmError = LipidUtil.PpmError(targetMz, msMsPrecursorMz);
if (Math.Abs(ppmError) > hcdMassError)
{
continue;
}
// Assign each MS/MS spectrum to HCD or CID
ProductSpectrum hcdSpectrum;
ProductSpectrum cidSpectrum;
if (firstMsMsSpectrum.ActivationMethod == ActivationMethod.HCD)
{
hcdSpectrum = firstMsMsSpectrum;
cidSpectrum = secondMsMsSpectrum;
}
else
{
hcdSpectrum = secondMsMsSpectrum;
cidSpectrum = firstMsMsSpectrum;
}
// Get all matching peaks
var hcdSearchResultList = hcdSpectrum != null ? (from msMsSearchUnit in msMsSearchUnits let peak = hcdSpectrum.FindPeak(msMsSearchUnit.Mz, hcdTolerance) select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
var cidSearchResultList = cidSpectrum != null ? (from msMsSearchUnit in msMsSearchUnits let peak = cidSpectrum.FindPeak(msMsSearchUnit.Mz, cidTolerance) select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
// Find the MS1 data
//Xic xic = lcmsRun.GetPrecursorExtractedIonChromatogram(targetMz, hcdTolerance, firstScanNumber);
var precursorScanNumber = 0;
if (lcmsRun.MinMsLevel == 1) //Make sure there are precursor scans in file
{
precursorScanNumber = lcmsRun.GetPrecursorScanNum(matchingMsMsScanNumbers[i]);
}
var precursorSpectrum = lcmsRun.GetSpectrum(precursorScanNumber);
var xic = lcmsRun.GetFullPrecursorIonExtractedIonChromatogram(targetMz, hcdTolerance);
// Bogus data
if (precursorSpectrum != null && (xic.GetApexScanNum() < 0 || xic.GetSumIntensities() <= 0))
{
continue;
}
SpectrumSearchResult spectrumSearchResult;
if (precursorSpectrum != null)
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, precursorSpectrum, hcdSearchResultList, cidSearchResultList, xic, lcmsRun, scoreModel, target)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
}
else //If there are no precursor scans in this file
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, hcdSearchResultList, cidSearchResultList, lcmsRun, scoreModel, target)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm),
};
}
spectrumSearchResultList.Add(spectrumSearchResult);
}
return(spectrumSearchResultList);
}
public static List <SpectrumSearchResult> RunFragmentWorkflow(ICollection <MsMsSearchUnit> fragments, LcMsRun lcmsRun, double hcdMassError, double cidMassError, int minMatches, IProgress <int> progress = null)
{
var PISearchUnits = fragments.Where(x => x.Description.Equals("Product Ion")).ToList();
var hcdTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm);
var cidTolerance = new Tolerance(cidMassError, ToleranceUnit.Ppm);
var scanTracker = new List <int>(); //track what scans have been included in spectrumSearchResultsList so we don't make duplicate entries for matched CID and HCD
// Find all MS/MS scans
var msmsScanNumers = lcmsRun.GetScanNumbers(2);
var spectrumSearchResultList = new List <SpectrumSearchResult>();
var maxScans = msmsScanNumers.Count;
foreach (var scan in msmsScanNumers)
{
// Lookup the MS/MS Spectrum
var MsMsSpectrum = lcmsRun.GetSpectrum(scan) as ProductSpectrum;
if (MsMsSpectrum == null)
{
continue;
}
ProductSpectrum MatchedSpectrum = null;
var spectrum1 = lcmsRun.GetSpectrum(scan + 1);
var spectrum2 = lcmsRun.GetSpectrum(scan - 1);
if (spectrum1 != null && spectrum1.MsLevel == 2)
{
var productSpectrum = spectrum1 as ProductSpectrum;
if (productSpectrum != null)
{
var deltaMz = productSpectrum.IsolationWindow.IsolationWindowTargetMz - MsMsSpectrum.IsolationWindow.IsolationWindowTargetMz;
if (Math.Abs(deltaMz) < float.Epsilon)
{
MatchedSpectrum = productSpectrum;
}
}
}
if (spectrum2 != null && spectrum2.MsLevel == 2)
{
var productSpectrum = spectrum2 as ProductSpectrum;
if (productSpectrum != null)
{
var deltaMz = productSpectrum.IsolationWindow.IsolationWindowTargetMz - MsMsSpectrum.IsolationWindow.IsolationWindowTargetMz;
if (Math.Abs(deltaMz) < float.Epsilon)
{
MatchedSpectrum = productSpectrum;
}
}
}
if (scanTracker.Contains(MsMsSpectrum.ScanNum))
{
continue;
}
var msmsPrecursorMz = MsMsSpectrum.IsolationWindow.IsolationWindowTargetMz;
var xic = lcmsRun.GetFullPrecursorIonExtractedIonChromatogram(msmsPrecursorMz, hcdTolerance);
// Bogus data
//if (xic.GetApexScanNum() < 0) continue;
var msmsPrecursorScan = 0;
if (lcmsRun.MinMsLevel == 1) //Make sure there are precursor scans in file
{
msmsPrecursorScan = lcmsRun.GetPrecursorScanNum(scan);
}
var precursorSpectrum = lcmsRun.GetSpectrum(msmsPrecursorScan);
// Get all matching peaks
//IEnumerable<MsMsSearchUnit> NLSearchUnits = fragments.Where(x=> x.Description.Equals("Neutral Loss")).Select(x => {x.Mz = (msmsPrecursorMz - x.Mz); return x;});
var NLSearchUnits = fragments.Where(x => x.Description.Equals("Neutral Loss")).Select(y => new MsMsSearchUnit(msmsPrecursorMz - y.Mz, "Neutral Loss"));
var MsMsSearchUnits = PISearchUnits.Concat(NLSearchUnits).ToList();
SpectrumSearchResult spectrumSearchResult;
var hcdSpectrum = MsMsSpectrum.ActivationMethod == ActivationMethod.HCD ? MsMsSpectrum : MatchedSpectrum;
var cidSpectrum = MsMsSpectrum.ActivationMethod == ActivationMethod.CID ? MsMsSpectrum : MatchedSpectrum;
var HcdSearchResultList = hcdSpectrum != null? (from msMsSearchUnit in MsMsSearchUnits
let peak = hcdSpectrum.FindPeak(msMsSearchUnit.Mz, hcdTolerance)
select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
var CidSearchResultList = cidSpectrum != null? (from msMsSearchUnit in MsMsSearchUnits
let peak = cidSpectrum.FindPeak(msMsSearchUnit.Mz, cidTolerance)
select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
var SearchResultList = HcdSearchResultList.Concat(CidSearchResultList).ToList();
if (precursorSpectrum != null)
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, precursorSpectrum,
HcdSearchResultList, CidSearchResultList, xic, lcmsRun)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
}
else
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, HcdSearchResultList, CidSearchResultList, lcmsRun)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
}
if (hcdSpectrum != null)
{
scanTracker.Add(hcdSpectrum.ScanNum);
}
if (cidSpectrum != null)
{
scanTracker.Add(cidSpectrum.ScanNum);
}
if (SearchResultList.Count(x => x.ObservedPeak != null) < minMatches)
{
continue;
}
spectrumSearchResultList.Add(spectrumSearchResult);
// Report progress
if (progress != null)
{
var currentProgress = (int)((double)scan / maxScans * 100);
progress.Report(currentProgress);
}
}
return(spectrumSearchResultList);
}
public static List <LipidGroupSearchResult> RunGlobalWorkflow(IEnumerable <Lipid> lipidList, LcMsRun lcmsRun, double hcdMassError, double cidMassError, ScoreModel scoreModel, IProgress <int> progress = null)
{
//TextWriter textWriter = new StreamWriter("outputNeg.tsv");
var lipidGroupSearchResultList = new List <LipidGroupSearchResult>();
var hcdTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm);
var cidTolerance = new Tolerance(cidMassError, ToleranceUnit.Ppm);
//var lipidsGroupedByTarget = lipidList.OrderBy(x => x.LipidTarget.Composition.Mass).GroupBy(x => x.LipidTarget).ToList(); //order by mz
var lipidsGroupedByTarget = lipidList.OrderBy(x => x.LipidTarget.MzRounded).GroupBy(x => x.LipidTarget).ToList();
var minLcScan = lcmsRun.MinLcScan;
double maxLcScan = lcmsRun.MaxLcScan;
var activationMethodCombination = FigureOutActivationMethodCombination(lcmsRun);
if (activationMethodCombination == ActivationMethodCombination.Unsupported)
{
throw new SystemException("Unsupported activation method.");
}
var useTwoScans = activationMethodCombination == ActivationMethodCombination.CidThenHcd || activationMethodCombination == ActivationMethodCombination.HcdThenCid;
for (var i = minLcScan; i <= maxLcScan; i++)
{
// Lookup the MS/MS Spectrum
var firstMsMsSpectrum = lcmsRun.GetSpectrum(i) as ProductSpectrum;
if (firstMsMsSpectrum == null)
{
continue;
}
// Lookup the MS/MS Spectrum
ProductSpectrum secondMsMsSpectrum = null;
if (useTwoScans)
{
secondMsMsSpectrum = lcmsRun.GetSpectrum(i + 1) as ProductSpectrum;
if (secondMsMsSpectrum == null)
{
continue;
}
// If m/z values of the MS/MS spectrums do not match, just move on
var deltaMz = firstMsMsSpectrum.IsolationWindow.IsolationWindowTargetMz -
secondMsMsSpectrum.IsolationWindow.IsolationWindowTargetMz;
if (Math.Abs(deltaMz) > 0.01)
{
continue;
}
}
//textWriter.WriteLine(i);
//Console.WriteLine(DateTime.Now + "\tProcessing Scan" + i);
// Grab Precursor Spectrum
var precursorScanNumber = 0;
if (lcmsRun.MinMsLevel == 1) //Make sure there are precursor scans in file
{
precursorScanNumber = lcmsRun.GetPrecursorScanNum(i);
}
var precursorSpectrum = lcmsRun.GetSpectrum(precursorScanNumber);
// Assign each MS/MS spectrum to HCD or CID
ProductSpectrum hcdSpectrum;
ProductSpectrum cidSpectrum;
if (firstMsMsSpectrum.ActivationMethod == ActivationMethod.HCD)
{
hcdSpectrum = firstMsMsSpectrum;
cidSpectrum = secondMsMsSpectrum;
}
else
{
hcdSpectrum = secondMsMsSpectrum;
cidSpectrum = firstMsMsSpectrum;
}
var msMsPrecursorMz = firstMsMsSpectrum.IsolationWindow.IsolationWindowTargetMz;
var mzToSearchTolerance = hcdMassError * msMsPrecursorMz / 1000000;
var lowMz = msMsPrecursorMz - mzToSearchTolerance;
var highMz = msMsPrecursorMz + mzToSearchTolerance;
foreach (var grouping in lipidsGroupedByTarget)
{
var lipidTarget = grouping.Key;
var lipidMz = lipidTarget.MzRounded;
// If we reached the point where the m/z is too high, we can exit
if (lipidMz > highMz)
{
break;
}
if (lipidMz > lowMz)
{
// Find the MS1 data
//Xic xic = lcmsRun.GetPrecursorExtractedIonChromatogram(lipidMz, hcdTolerance, i);
var xic = lcmsRun.GetFullPrecursorIonExtractedIonChromatogram(lipidMz, hcdTolerance);
// Bogus data
if (precursorSpectrum != null && (xic.GetApexScanNum() < 0 || xic.GetSumIntensities() <= 0))
{
continue;
}
// Grab the MS/MS peak to search for
IEnumerable <MsMsSearchUnit> msMsSearchUnits = lipidTarget.GetMsMsSearchUnits();
// Get all matching peaks
var hcdSearchResultList = hcdSpectrum != null ? (from msMsSearchUnit in msMsSearchUnits let peak = hcdSpectrum.FindPeak(msMsSearchUnit.Mz, hcdTolerance) select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
var cidSearchResultList = cidSpectrum != null ? (from msMsSearchUnit in msMsSearchUnits let peak = cidSpectrum.FindPeak(msMsSearchUnit.Mz, cidTolerance) select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
// Create spectrum search results
SpectrumSearchResult spectrumSearchResult;
LipidGroupSearchResult lipidGroupSearchResult;
if (precursorSpectrum != null)
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, precursorSpectrum, hcdSearchResultList, cidSearchResultList, xic, lcmsRun)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
lipidGroupSearchResult = new LipidGroupSearchResult(lipidTarget, grouping.ToList(), spectrumSearchResult, scoreModel);
}
else //If there are no precursor scans in this file
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, hcdSearchResultList, cidSearchResultList, lcmsRun)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
lipidGroupSearchResult = new LipidGroupSearchResult(lipidTarget, grouping.ToList(), spectrumSearchResult, scoreModel);
}
lipidGroupSearchResultList.Add(lipidGroupSearchResult);
}
}
// Skip an extra scan if we look at 2 at a time
if (useTwoScans)
{
i++;
}
// Report progress
if (progress != null)
{
var currentProgress = (int)(i / maxLcScan * 100);
progress.Report(currentProgress);
}
}
//textWriter.Close();
return(lipidGroupSearchResultList);
}
/*
* public static List<LipidGroupSearchResult> RunGlobalWorkflow(IEnumerable<Lipid> lipidList, DataReader ImsRun, IEnumerable<ImsFeature> FeatureTargets, double hcdMassError,double cidMassError, ScoreModel scoreModel, IProgress<int> progress = null)
* {
* Tolerance hcdTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm);
* Tolerance cidTolerance = new Tolerance(cidMassError, ToleranceUnit.Ppm);
*
* var lipidsGroupedByTarget = lipidList.OrderBy(x => x.LipidTarget.Composition.Mass).GroupBy(x => x.LipidTarget).ToList();
* int MS1Frames = ImsRun.GetNumberOfFrames(DataReader.FrameType.MS1);
* int MS2Frames = ImsRun.GetNumberOfFrames(DataReader.FrameType.MS2);
*
* var gp = ImsRun.GetGlobalParams();
* var framelist = ImsRun.GetMasterFrameList();
*
* ActivationMethodCombination activationMethodCombination = MS2Frames > 0 ? ActivationMethodCombination.CidOnly : ActivationMethodCombination.Unsupported;
* if (activationMethodCombination == ActivationMethodCombination.Unsupported) throw new SystemException("Unsupported activation method.");
*
* List<Spectrum> Spectra = new List<Spectrum>();
* foreach (var feature in FeatureTargets)
* {
* double mzToSearchTolerance = hcdMassError * feature.Mz / 1000000;
* double lowMz = feature.Mz - mzToSearchTolerance;
* double highMz = feature.Mz + mzToSearchTolerance;
*
* double[] mzArray;
* int[] intensityArray;
* ImsRun.GetSpectrum(feature.LcStart, feature.LcEnd, DataReader.FrameType.MS1, feature.ImsStart,
* feature.ImsEnd, out mzArray, out intensityArray);
*
* foreach (var mz in mzArray)
* {
* if (mz > highMz) break;
* if (mz > lowMz)
* {
* //Target IMS feature found in this scan
* double[] MS2Mz;
* int[] MS2Ints;
* ImsRun.GetSpectrum(feature.LcStart, feature.LcEnd, DataReader.FrameType.MS2, feature.ImsStart,
* feature.ImsEnd, out MS2Mz, out MS2Ints);
* var MS2Intensity = (from intensity in MS2Ints select (double) (intensity)).ToArray();
* Spectrum spec = new ProductSpectrum(MS2Mz, MS2Intensity, feature.ImsScan);
* spec.MsLevel = 2;
* Spectra.Add(spec);
* }
* }
*
*
* /*
* for (int lcScan = feature.LcStart; lcScan <= feature.LcEnd; lcScan++)
* {
* if (framelist[lcScan] == DataReader.FrameType.MS1)
* {
* for (int imsScan = feature.ImsStart; imsScan <= feature.ImsEnd; imsScan++)
* {
* double[] mzArray;
* int[] intensityArray;
* ImsRun.GetSpectrum(lcScan, lcScan, DataReader.FrameType.MS1, imsScan, imsScan, out mzArray, out intensityArray);
*
* foreach (var mz in mzArray)
* {
* if (mz > highMz) break;
* if (mz > lowMz)
* {
* //Target IMS feature found in this scan
* feature.AddCoord(lcScan, imsScan);
* }
* }
* }
* }
* }
* }
*
* return new List<LipidGroupSearchResult>();
* }
*/
public static List <LipidGroupSearchResult> RunGlobalWorkflowAvgSpec(
IEnumerable <Lipid> lipidList,
LcMsRun lcmsRun,
double hcdMassError,
double cidMassError,
ScoreModel scoreModel,
IProgress <int> progress = null)
{
var lipidGroupSearchResultList = new List <LipidGroupSearchResult>();
var hcdTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm);
var cidTolerance = new Tolerance(cidMassError, ToleranceUnit.Ppm);
var lipidsGroupedByTarget = lipidList.OrderBy(x => x.LipidTarget.MzRounded).GroupBy(x => x.LipidTarget).ToList();
var minLcScan = lcmsRun.MinLcScan;
double maxLcScan = lcmsRun.MaxLcScan;
var ms2scans = lcmsRun.GetScanNumbers(2);
var ms2spectra = ms2scans.Select(scan => lcmsRun.GetSpectrum(scan) as ProductSpectrum).ToList();
var uniqueMz = (from spectrum in ms2spectra select spectrum.IsolationWindow.IsolationWindowTargetMz).ToList().Distinct().ToList();
foreach (var mz in uniqueMz)
{
var hcdScans = ms2spectra.Where(x => Math.Abs(x.IsolationWindow.IsolationWindowTargetMz - mz) < float.Epsilon && x.ActivationMethod == ActivationMethod.HCD).Select(x => x.ScanNum).ToList();
var summedSpec = lcmsRun.GetSummedSpectrum(hcdScans);
var summedHcdSpec = new ProductSpectrum(summedSpec.Peaks, 0)
{
ActivationMethod = ActivationMethod.HCD
};
var cidScans = ms2spectra.Where(x => Math.Abs(x.IsolationWindow.IsolationWindowTargetMz - mz) < float.Epsilon && x.ActivationMethod == ActivationMethod.CID).Select(x => x.ScanNum).ToList();
summedSpec = lcmsRun.GetSummedSpectrum(cidScans);
var summedCidSpec = new ProductSpectrum(summedSpec.Peaks, 0)
{
ActivationMethod = ActivationMethod.CID
};
var HcdPresent = summedHcdSpec.Peaks.Any();
var CidPresent = summedCidSpec.Peaks.Any();
if (HcdPresent)
{
summedHcdSpec.IsolationWindow = new IsolationWindow(mz, hcdMassError, hcdMassError);
}
if (CidPresent)
{
summedCidSpec.IsolationWindow = new IsolationWindow(mz, cidMassError, cidMassError);
}
var mzToSearchTolerance = hcdMassError * mz / 1000000;
var lowMz = mz - mzToSearchTolerance;
var highMz = mz + mzToSearchTolerance;
var hcdSpectrum = summedHcdSpec;
var cidSpectrum = summedCidSpec;
Spectrum precursorSpectrum = null;
foreach (var grouping in lipidsGroupedByTarget)
{
var lipidTarget = grouping.Key;
var lipidMz = lipidTarget.MzRounded;
// If we reached the point where the m/z is too high, we can exit
if (lipidMz > highMz)
{
break;
}
if (lipidMz > lowMz)
{
// Find the MS1 data
//Xic xic = lcmsRun.GetPrecursorExtractedIonChromatogram(lipidMz, hcdTolerance, i);
var xic = lcmsRun.GetFullPrecursorIonExtractedIonChromatogram(lipidMz, hcdTolerance);
// Bogus data
if (precursorSpectrum != null && (xic.GetApexScanNum() < 0 || xic.GetSumIntensities() <= 0))
{
continue;
}
// Grab the MS/MS peak to search for
IEnumerable <MsMsSearchUnit> msMsSearchUnits = lipidTarget.GetMsMsSearchUnits();
// Get all matching peaks
var hcdSearchResultList = hcdSpectrum != null ? (from msMsSearchUnit in msMsSearchUnits let peak = hcdSpectrum.FindPeak(msMsSearchUnit.Mz, hcdTolerance) select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
var cidSearchResultList = cidSpectrum != null ? (from msMsSearchUnit in msMsSearchUnits let peak = cidSpectrum.FindPeak(msMsSearchUnit.Mz, cidTolerance) select new MsMsSearchResult(msMsSearchUnit, peak)).ToList() : new List <MsMsSearchResult>();
// Create spectrum search results
SpectrumSearchResult spectrumSearchResult;
LipidGroupSearchResult lipidGroupSearchResult;
if (precursorSpectrum != null)
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, precursorSpectrum, hcdSearchResultList, cidSearchResultList, xic, lcmsRun)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
lipidGroupSearchResult = new LipidGroupSearchResult(lipidTarget, grouping.ToList(), spectrumSearchResult, scoreModel);
}
else //If there are no precursor scans in this file
{
spectrumSearchResult = new SpectrumSearchResult(hcdSpectrum, cidSpectrum, hcdSearchResultList, cidSearchResultList, lcmsRun)
{
PrecursorTolerance = new Tolerance(hcdMassError, ToleranceUnit.Ppm)
};
lipidGroupSearchResult = new LipidGroupSearchResult(lipidTarget, grouping.ToList(), spectrumSearchResult, scoreModel);
}
lipidGroupSearchResultList.Add(lipidGroupSearchResult);
//textWriter.WriteLine(lipidTarget.CommonName + "\t" + spectrumSearchResult.Score);
//Console.WriteLine(lipidTarget.CommonName + "\t" + spectrumSearchResult.Score);
}
}
}
//var summedHcdSpectra = uniqueMz.Select(mz => new Tuple<double, ProductSpectrum>(mz, lcmsRun.GetSummedMs2Spectrum(mz, minLcScan, (int)maxLcScan, 1, 2, ActivationMethod.HCD))).ToDictionary(x => x.Item1, x => x.Item2);
//if (summedHcdSpectra != null) { foreach (var spec in summedHcdSpectra) { spec.Value.IsolationWindow = new IsolationWindow(spec.Key, spec.Key, spec.Key); } }
//var summedCidSpectra = uniqueMz.Select(mz => lcmsRun.GetSummedMs2Spectrum(mz, minLcScan, (int)maxLcScan, 1, 2, ActivationMethod.CID)).ToList();
return(lipidGroupSearchResultList);
}
