private DatabaseSequenceSpectrumMatch[] RunGeneratingFunction(SortedSet<DatabaseSequenceSpectrumMatch>[] sortedMatches, CancellationToken? cancellationToken = null, IProgress<ProgressData> progress = null)
{
var progData = new ProgressData(progress)
{
Status = "Calculating spectral E-values for matches"
};
if (_cachedScoreDistributions == null)
{
_cachedScoreDistributions = new LinkedList<Tuple<double, ScoreDistribution>>[_run.MaxLcScan + 1];
foreach (var scanNum in _ms2ScanNums) _cachedScoreDistributions[scanNum] = new LinkedList<Tuple<double, ScoreDistribution>>();
}
var sw = new Stopwatch();
var topDownScorer = new InformedTopDownScorer(_run, AminoAcidSet, MinProductIonCharge, MaxProductIonCharge, ProductIonTolerance);
// Rescore and Estimate #proteins for GF calculation
var matches = new LinkedList<DatabaseSequenceSpectrumMatch>[sortedMatches.Length];
long estimatedProteins = 0;
foreach(var scanNum in _ms2ScanNums)
{
var prsms = sortedMatches[scanNum];
if (prsms == null) continue;
var spec = _run.GetSpectrum(scanNum) as ProductSpectrum;
if (spec == null) return null;
foreach (var match in prsms)
{
var sequence = match.Sequence;
var ion = match.Ion;
// Re-scoring
var scores = topDownScorer.GetScores(spec, sequence, ion.Composition, ion.Charge, scanNum);
if (scores == null) continue;
match.Score = scores.Score;
match.ModificationText = scores.Modifications;
match.NumMatchedFragments = scores.NumMatchedFrags;
if (match.Score > CompositeScorer.ScoreParam.Cutoff)
{
if (matches[scanNum] == null) matches[scanNum] = new LinkedList<DatabaseSequenceSpectrumMatch>();
matches[scanNum].AddLast(match);
}
}
if (matches[scanNum] != null) estimatedProteins += matches[scanNum].Count;
}
Console.WriteLine(@"Estimated matched proteins: " + estimatedProteins);
var numProteins = 0;
var lastUpdate = DateTime.MinValue; // Force original update of 0%
sw.Reset();
sw.Start();
var scanNums = _ms2ScanNums.Where(scanNum => matches[scanNum] != null).ToArray();
var pfeOptions = new ParallelOptions
{
MaxDegreeOfParallelism = MaxNumThreads,
CancellationToken = cancellationToken ?? CancellationToken.None
};
Parallel.ForEach(scanNums, pfeOptions, scanNum =>
{
var currentTask = "?";
try
{
var scoreDistributions = _cachedScoreDistributions[scanNum];
foreach (var match in matches[scanNum])
{
var currentIteration = "for scan " + scanNum + " and mass " + match.Ion.Composition.Mass;
currentTask = "Calling GetMs2ScoringGraph " + currentIteration;
var graph = _ms2ScorerFactory2.GetMs2ScoringGraph(scanNum, match.Ion.Composition.Mass);
if (graph == null) continue;
currentTask = "Calling ComputeGeneratingFunction " + currentIteration;
var scoreDist = (from distribution in scoreDistributions
where Math.Abs(distribution.Item1 - match.Ion.Composition.Mass) < PrecursorIonTolerance.GetToleranceAsTh(match.Ion.Composition.Mass)
select distribution.Item2).FirstOrDefault();
if (scoreDist == null)
{
var gf = new GeneratingFunction(graph);
gf.ComputeGeneratingFunction();
scoreDist = gf.GetScoreDistribution();
scoreDistributions.AddLast(new Tuple<double, ScoreDistribution>(match.Ion.Composition.Mass, scoreDist));
}
currentTask = "Calling GetSpectralEValue " + currentIteration + " and score " + (int)match.Score;
match.SpecEvalue = scoreDist.GetSpectralEValue(match.Score);
currentTask = "Reporting progress " + currentIteration;
SearchProgressReport(ref numProteins, ref lastUpdate, estimatedProteins, sw, progData);
}
}
catch (Exception ex)
{
var errMsg = string.Format("Exception while {0}: {1}", currentTask, ex.Message);
Console.WriteLine(errMsg);
throw new Exception(errMsg, ex);
}
});
var finalMatches = new DatabaseSequenceSpectrumMatch[matches.Length];
foreach (var scanNum in scanNums)
{
finalMatches[scanNum] = matches[scanNum].OrderBy(m => m.SpecEvalue).First();
}
progData.StatusInternal = string.Empty;
progData.Report(100.0);
return finalMatches;
}
private void SearchProgressReport(ref int numProteins, ref DateTime lastUpdate, long estimatedProteins, Stopwatch sw, ProgressData progData, string itemName = "proteins")
{
var tempNumProteins = Interlocked.Increment(ref numProteins) - 1;
if (estimatedProteins < 1)
estimatedProteins = 1;
progData.StatusInternal = string.Format(@"Processing, {0} {1} done, {2:#0.0}% complete, {3:f1} sec elapsed",
tempNumProteins,
itemName,
tempNumProteins / (double)estimatedProteins * 100.0,
sw.Elapsed.TotalSeconds);
progData.Report(tempNumProteins, estimatedProteins);
int secondsThreshold;
if (sw.Elapsed.TotalMinutes < 2)
secondsThreshold = 15; // Every 15 seconds
else if (sw.Elapsed.TotalMinutes < 5)
secondsThreshold = 30; // Every 30 seconds
else if (sw.Elapsed.TotalMinutes < 20)
secondsThreshold = 60; // Every 1 minute
else
secondsThreshold = 300; // Every 5 minutes
if (DateTime.UtcNow.Subtract(lastUpdate).TotalSeconds >= secondsThreshold)
{
lastUpdate = DateTime.UtcNow;
Console.WriteLine(@"Processing, {0} {1} done, {2:#0.0}% complete, {3:f1} sec elapsed",
tempNumProteins,
itemName,
tempNumProteins / (double)estimatedProteins * 100.0,
sw.Elapsed.TotalSeconds);
}
}
private SequenceTagGenerator GetSequenceTagGenerator(CancellationToken? cancellationToken = null, IProgress<ProgressData> progress = null)
{
var sequenceTagGen = new SequenceTagGenerator(_run, new Tolerance(5));
var scanNums = _ms2ScanNums;
var progData = new ProgressData(progress)
{
Status = "Generating sequence tags"
};
var sw = new Stopwatch();
// Rescore and Estimate #proteins for GF calculation
long estimatedProteins = scanNums.Length;
Console.WriteLine(@"Number of spectra: " + estimatedProteins);
var numProteins = 0;
var lastUpdate = DateTime.MinValue; // Force original update of 0%
sw.Reset();
sw.Start();
var pfeOptions = new ParallelOptions
{
MaxDegreeOfParallelism = MaxNumThreads,
CancellationToken = cancellationToken ?? CancellationToken.None
};
Parallel.ForEach(scanNums, pfeOptions, scanNum =>
{
sequenceTagGen.Generate(scanNum);
SearchProgressReport(ref numProteins, ref lastUpdate, estimatedProteins, sw, progData,
"spectra");
});
progData.StatusInternal = string.Empty;
progData.Report(100.0);
Console.WriteLine(@"Generated sequence tags: " + sequenceTagGen.NumberOfGeneratedTags());
return sequenceTagGen;
}
private void RunSearch(SortedSet<DatabaseSequenceSpectrumMatch>[] matches, FastaDatabase db, ISequenceFilter sequenceFilter, CancellationToken? cancellationToken = null, IProgress<ProgressData> progress = null)
{
var progData = new ProgressData(progress)
{
Status = "Searching for matches"
};
var sw = new Stopwatch();
long estimatedProteins;
var annotationsAndOffsets = GetAnnotationsAndOffsets(db, out estimatedProteins, cancellationToken);
Console.WriteLine(@"Estimated proteins: " + estimatedProteins);
var numProteins = 0;
var lastUpdate = DateTime.MinValue; // Force original update of 0%
sw.Reset();
sw.Start();
var pfeOptions = new ParallelOptions
{
MaxDegreeOfParallelism = MaxNumThreads,
CancellationToken = cancellationToken ?? CancellationToken.None
};
var maxNumNTermCleavages = SearchMode == InternalCleavageType.NoInternalCleavage ? MaxNumNTermCleavages : 0;
//foreach (var annotationAndOffset in annotationsAndOffsets)
Parallel.ForEach(annotationsAndOffsets, pfeOptions, annotationAndOffset =>
{
if (cancellationToken != null && cancellationToken.Value.IsCancellationRequested)
{
//return matches;
return;
}
SearchProgressReport(ref numProteins, ref lastUpdate, estimatedProteins, sw, progData);
SearchForMatches(annotationAndOffset, sequenceFilter, matches, maxNumNTermCleavages, db.IsDecoy, cancellationToken);
});
Console.WriteLine(@"Collected candidate matches: {0}", GetNumberOfMatches(matches));
progData.StatusInternal = string.Empty;
progData.Report(100.0);
}
private void RunTagBasedSearch(SortedSet<DatabaseSequenceSpectrumMatch>[] matches, FastaDatabase db,
CancellationToken? cancellationToken = null, IProgress<ProgressData> progress = null)
{
_tagSearchEngine.SetDatabase(db);
//var ms2ScanNums = _run.GetScanNumbers(2);
var progData = new ProgressData(progress)
{
Status = "Tag-based Searching for matches"
};
var sw = new Stopwatch();
long estimatedProteins = _tagMs2ScanNum.Length;
Console.WriteLine(@"Number of spectra containing sequence tags: " + estimatedProteins);
var numProteins = 0;
var lastUpdate = DateTime.MinValue; // Force original update of 0%
sw.Reset();
sw.Start();
var pfeOptions = new ParallelOptions
{
MaxDegreeOfParallelism = MaxNumThreads,
CancellationToken = cancellationToken ?? CancellationToken.None
};
Parallel.ForEach(_tagMs2ScanNum, pfeOptions, ms2ScanNum =>
{
var tagSeqMatches = _tagSearchEngine.RunSearch(ms2ScanNum);
foreach (var tagSequenceMatch in tagSeqMatches)
{
var offset = _tagSearchEngine.FastaDatabase.GetOffset(tagSequenceMatch.ProteinName);
if (offset == null) continue;
var sequence = tagSequenceMatch.Sequence;
var numNTermCleavages = tagSequenceMatch.TagMatch.StartIndex;
var seqObj = Sequence.CreateSequence(sequence, tagSequenceMatch.TagMatch.ModificationText, AminoAcidSet);
var precursorIon = new Ion(seqObj.Composition + Composition.H2O, tagSequenceMatch.TagMatch.Charge);
var prsm = new DatabaseSequenceSpectrumMatch(sequence, tagSequenceMatch.Pre, tagSequenceMatch.Post,
ms2ScanNum, (long)offset, numNTermCleavages,
tagSequenceMatch.TagMatch.Modifications,
precursorIon, tagSequenceMatch.TagMatch.Score, db.IsDecoy)
{
ModificationText = tagSequenceMatch.TagMatch.ModificationText,
};
AddMatch(matches, ms2ScanNum, prsm);
}
SearchProgressReport(ref numProteins, ref lastUpdate, estimatedProteins, sw, progData, "spectra");
});
Console.WriteLine(@"Collected candidate matches: {0}", GetNumberOfMatches(matches));
progData.StatusInternal = string.Empty;
progData.Report(100.0);
}
public bool RunSearch(double corrThreshold = 0.7, CancellationToken? cancellationToken = null, IProgress<ProgressData> progress = null)
{
// Get the Normalized spec file/folder path
SpecFilePath = MassSpecDataReaderFactory.NormalizeDatasetPath(SpecFilePath);
var prog = new Progress<ProgressData>();
var progData = new ProgressData(progress);
if (progress != null)
{
prog = new Progress<ProgressData>(p =>
{
progData.Status = p.Status;
progData.StatusInternal = p.StatusInternal;
progData.Report(p.Percent);
});
}
var sw = new Stopwatch();
var swAll = new Stopwatch();
swAll.Start();
ErrorMessage = string.Empty;
Console.Write(@"Reading raw file...");
progData.Status = "Reading spectra file";
progData.StepRange(10.0);
sw.Start();
_run = PbfLcMsRun.GetLcMsRun(SpecFilePath, 0, 0, prog);
_ms2ScanNums = _run.GetScanNumbers(2).ToArray();
_isolationWindowTargetMz = new double[_run.MaxLcScan + 1];
foreach (var ms2Scan in _ms2ScanNums)
{
var ms2Spec = _run.GetSpectrum(ms2Scan) as ProductSpectrum;
if (ms2Spec == null) continue;
_isolationWindowTargetMz[ms2Scan] = ms2Spec.IsolationWindow.IsolationWindowTargetMz;
}
sw.Stop();
Console.WriteLine(@"Elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
progData.StepRange(20.0);
ISequenceFilter ms1Filter;
if (this.ScanNumbers != null && this.ScanNumbers.Any())
{
ms1Filter = new SelectedMsMsFilter(this.ScanNumbers);
}
else if (string.IsNullOrWhiteSpace(FeatureFilePath))
{
// Checks whether SpecFileName.ms1ft exists
var ms1FtFilePath = MassSpecDataReaderFactory.ChangeExtension(SpecFilePath, LcMsFeatureFinderLauncher.FileExtension);
if (!File.Exists(ms1FtFilePath))
{
Console.WriteLine(@"Running ProMex...");
sw.Start();
var param = new LcMsFeatureFinderInputParameter
{
InputPath = SpecFilePath,
MinSearchMass = MinSequenceMass,
MaxSearchMass = MaxSequenceMass,
MinSearchCharge = MinPrecursorIonCharge,
MaxSearchCharge = MaxPrecursorIonCharge,
CsvOutput = false,
ScoreReport = false,
LikelihoodScoreThreshold = -10
};
var featureFinder = new LcMsFeatureFinderLauncher(param);
featureFinder.Run();
}
sw.Reset();
sw.Start();
Console.Write(@"Reading ProMex results...");
ms1Filter = new Ms1FtFilter(_run, PrecursorIonTolerance, ms1FtFilePath, -10);
}
else
{
sw.Reset();
sw.Start();
var extension = Path.GetExtension(FeatureFilePath);
if (extension.ToLower().Equals(".csv"))
{
Console.Write(@"Reading ICR2LS/Decon2LS results...");
ms1Filter = new IsosFilter(_run, PrecursorIonTolerance, FeatureFilePath);
}
else if (extension.ToLower().Equals(".ms1ft"))
{
Console.Write(@"Reading ProMex results...");
ms1Filter = new Ms1FtFilter(_run, PrecursorIonTolerance, FeatureFilePath, -10);
}
else if (extension.ToLower().Equals(".msalign"))
{
Console.Write(@"Reading MS-Align+ results...");
ms1Filter = new MsDeconvFilter(_run, PrecursorIonTolerance, FeatureFilePath);
}
else ms1Filter = null; //new Ms1FeatureMatrix(_run);
}
sw.Stop();
Console.WriteLine(@"Elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
// pre-generate deconvoluted spectra for scoring
_massBinComparer = new FilteredProteinMassBinning(AminoAcidSet, MaxSequenceMass+1000);
_ms2ScorerFactory2 = new CompositeScorerFactory(_run, _massBinComparer, AminoAcidSet,
MinProductIonCharge, MaxProductIonCharge, ProductIonTolerance);
sw.Reset();
Console.WriteLine(@"Generating deconvoluted spectra for MS/MS spectra...");
sw.Start();
var pfeOptions = new ParallelOptions
{
MaxDegreeOfParallelism = MaxNumThreads,
CancellationToken = cancellationToken ?? CancellationToken.None
};
Parallel.ForEach(_ms2ScanNums, pfeOptions, ms2ScanNum =>
{
_ms2ScorerFactory2.DeconvonluteProductSpectrum(ms2ScanNum);
});
sw.Stop();
Console.WriteLine(@"Elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
progData.StepRange(10.0);
progData.Status = "Reading Fasta File";
// Target database
var targetDb = new FastaDatabase(DatabaseFilePath);
targetDb.Read();
// Generate sequence tags for all MS/MS spectra
if (TagBasedSearch)
{
progData.StepRange(25.0);
progData.Status = "Generating Sequence Tags";
sw.Reset();
Console.WriteLine(@"Generating sequence tags for MS/MS spectra...");
sw.Start();
var seqTagGen = GetSequenceTagGenerator();
_tagMs2ScanNum = seqTagGen.GetMs2ScanNumsContainingTags().ToArray();
sw.Stop();
Console.WriteLine(@"Elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
_tagSearchEngine = new ScanBasedTagSearchEngine(_run, seqTagGen, new LcMsPeakMatrix(_run, ms1Filter), targetDb, ProductIonTolerance, AminoAcidSet,
_ms2ScorerFactory2,
ScanBasedTagSearchEngine.DefaultMinMatchedTagLength,
MaxSequenceMass, MinProductIonCharge, MaxProductIonCharge);
}
var specFileName = MassSpecDataReaderFactory.RemoveExtension(Path.GetFileName(SpecFilePath));
var targetOutputFilePath = Path.Combine(OutputDir, specFileName + TargetFileNameEnding);
var decoyOutputFilePath = Path.Combine(OutputDir, specFileName + DecoyFileNameEnding);
var tdaOutputFilePath = Path.Combine(OutputDir, specFileName + TdaFileNameEnding);
progData.StepRange(60.0);
progData.Status = "Running Target search";
if (RunTargetDecoyAnalysis.HasFlag(DatabaseSearchMode.Target))
{
sw.Reset();
Console.Write(@"Reading the target database...");
sw.Start();
targetDb.Read();
sw.Stop();
Console.WriteLine(@"Elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
var targetMatches = new SortedSet<DatabaseSequenceSpectrumMatch>[_run.MaxLcScan + 1];
progData.MaxPercentage = 42.5;
if (TagBasedSearch)
{
sw.Reset();
Console.WriteLine(@"Tag-based searching the target database");
sw.Start();
RunTagBasedSearch(targetMatches, targetDb, null, prog);
Console.WriteLine(@"Target database tag-based search elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
}
progData.MaxPercentage = 60.0;
sw.Reset();
Console.WriteLine(@"Searching the target database");
sw.Start();
RunSearch(targetMatches, targetDb, ms1Filter, null, prog);
Console.WriteLine(@"Target database search elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
// calculate spectral e-value usign generating function
sw.Reset();
Console.WriteLine(@"Calculating spectral E-values for target-spectrum matches");
sw.Start();
var bestTargetMatches = RunGeneratingFunction(targetMatches);
WriteResultsToFile(bestTargetMatches, targetOutputFilePath, targetDb);
sw.Stop();
Console.WriteLine(@"Target-spectrum match E-value calculation elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
}
progData.StepRange(95.0); // total to 95%
progData.Status = "Running Decoy search";
if (RunTargetDecoyAnalysis.HasFlag(DatabaseSearchMode.Decoy))
{
// Decoy database
sw.Reset();
sw.Start();
var decoyDb = targetDb.Decoy(null, true);
Console.Write(@"Reading the decoy database...");
decoyDb.Read();
Console.WriteLine(@"Elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
progData.MaxPercentage = 77.5;
var decoyMatches = new SortedSet<DatabaseSequenceSpectrumMatch>[_run.MaxLcScan + 1];
if (TagBasedSearch)
{
sw.Reset();
Console.WriteLine(@"Tag-based searching the decoy database");
sw.Start();
RunTagBasedSearch(decoyMatches, decoyDb, null, prog);
Console.WriteLine(@"Decoy database tag-based search elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
}
progData.MaxPercentage = 95.0;
sw.Reset();
Console.WriteLine(@"Searching the decoy database");
sw.Start();
RunSearch(decoyMatches, decoyDb, ms1Filter, null, prog);
Console.WriteLine(@"Decoy database search elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
// calculate spectral e-value usign generating function
sw.Reset();
Console.WriteLine(@"Calculating spectral E-values for decoy-spectrum matches");
sw.Start();
var bestDecoyMatches = RunGeneratingFunction(decoyMatches);
WriteResultsToFile(bestDecoyMatches, decoyOutputFilePath, decoyDb);
sw.Stop();
Console.WriteLine(@"Decoy-spectrum match E-value calculation elapsed Time: {0:f1} sec", sw.Elapsed.TotalSeconds);
}
progData.StepRange(100.0);
progData.Status = "Writing combined results file";
if (RunTargetDecoyAnalysis.HasFlag(DatabaseSearchMode.Both))
{
// Add "Qvalue" and "PepQValue"
var fdrCalculator = new FdrCalculator(targetOutputFilePath, decoyOutputFilePath);
if (fdrCalculator.HasError())
{
ErrorMessage = fdrCalculator.ErrorMessage;
Console.WriteLine(@"Error computing FDR: " + fdrCalculator.ErrorMessage);
return false;
}
fdrCalculator.WriteTo(tdaOutputFilePath);
}
progData.Report(100.0);
Console.WriteLine(@"Done.");
swAll.Stop();
Console.WriteLine(@"Total elapsed time for search: {0:f1} sec ({1:f2} min)", swAll.Elapsed.TotalSeconds, swAll.Elapsed.TotalMinutes);
return true;
}
/// <summary>
/// Try to find the best concentration of the selected isotope
/// by stepping through the concentrations and fitting a theoretical
/// isotopic profile to the provided observed peaks.
/// </summary>
/// <param name="progress">The progress reporter.</param>
public IsotopeConcentrationCorrelationCurve Tune(IProgress <ProgressData> progress = null)
{
// Set up progress reporter
var progressData = new ProgressData(progress);
this.ValidateParameters();
// Get default proportions for the selected element.
// Copy it to a new array so we can manipulate it.
var proportions = this.GetDefaultProportions(this.Element).ToArray();
// Make sure this is an isotope we know about and that it isn't the monoisotope
if (this.IsotopeIndex < 1 || this.IsotopeIndex >= proportions.Length)
{
throw new ArgumentOutOfRangeException("isotopeIndex");
}
var defaultProportion = proportions[this.IsotopeIndex];
// Set the default best point (the first one).
var results = new IsotopeConcentrationCorrelationCurve
{
BestConcentration = new IsotopeConcentrationCorrelationCurve.ConcentrationCorrelationPoint
{
IsotopeConcentration = defaultProportion,
MonoisotopeConcentration = proportions[0],
PearsonCorrelation = 0.0
}
};
// Iterate over concentration values
int numberOfSteps = (int)(this.MaxConcentration - defaultProportion / this.StepSize);
for (int i = 0; i <= numberOfSteps; i++)
{
// Update percent complete
progressData.Report(i, numberOfSteps);
// Calculate concentration
var concentrationStep = i * this.StepSize;
proportions[this.IsotopeIndex] += concentrationStep; // Increase isotope of interest
proportions[0] -= concentrationStep; // Decrease monoisotope
// Get theoretical isotope profile and align the observed peaks to it
var theoreticalIsotopeProfile = this.GetTheoreticalIsotopeProfile(proportions);
var alignedObservedPeaks = this.AlignObservedPeaks(this.ObservedPeaks, theoreticalIsotopeProfile, this.Tolerance);
// Break out the intensities of the isotope profiles
var theoIntensities = theoreticalIsotopeProfile.Select(peak => peak.Intensity).ToArray();
var obsIntensities = alignedObservedPeaks.Select(peak => peak.Intensity).ToArray();
// Compute pearson correlation
var pearsonCorrelation = FitScoreCalculator.GetPearsonCorrelation(obsIntensities, theoIntensities);
// Add data point for this concentration to result curve
var dataPoint = new IsotopeConcentrationCorrelationCurve.ConcentrationCorrelationPoint
{
IsotopeConcentration = proportions[this.IsotopeIndex],
MonoisotopeConcentration = proportions[0],
PearsonCorrelation = pearsonCorrelation
};
results.DataPoints.Add(dataPoint);
// If this concentration has a better fit, update the stored results
if (pearsonCorrelation >= results.BestConcentration.PearsonCorrelation)
{
results.BestConcentration = dataPoint;
}
}
return(results);
}
public InMemoryLcMsRun(
IMassSpecDataReader massSpecDataReader,
double precursorSignalToNoiseRatioThreshold,
double productSignalToNoiseRatioThreshold,
IProgress<ProgressData> progress = null,
int scanStart = 0,
int scanEnd = 0)
{
ScanNumElutionTimeMap = new Dictionary<int, double>();
ScanNumToMsLevel = new Dictionary<int, int>();
IsolationMzBinToScanNums = new Dictionary<int, int[]>();
_ms1PeakList = new List<LcMsPeak>();
_scanNumSpecMap = new Dictionary<int, Spectrum>();
var isolationMzBinToScanNums = new Dictionary<int, List<int>>();
// Read all spectra
var progressData = new ProgressData(progress)
{
Status = "Reading spectra from file"
};
var trackingInfo = new SpectrumTrackingInfo
{
NumSpectra = massSpecDataReader.NumSpectra,
PrecursorSignalToNoiseRatioThreshold = precursorSignalToNoiseRatioThreshold,
ProductSignalToNoiseRatioThreshold = productSignalToNoiseRatioThreshold,
SpecRead = 0,
MinScanNum = int.MaxValue,
MaxScanNum = int.MinValue,
MinMsLevel = int.MaxValue,
MaxMsLevel = int.MinValue
};
NumSpectra = massSpecDataReader.NumSpectra;
progressData.StepRange(95.0);
if (scanStart > 0 && scanEnd >= scanStart)
{
for (var scanNum = scanStart; scanNum <= scanEnd; scanNum++)
{
var spec = massSpecDataReader.ReadMassSpectrum(scanNum);
progressData.Report(trackingInfo.SpecRead, trackingInfo.NumSpectra);
HandleSpectrum(ref trackingInfo, isolationMzBinToScanNums, spec);
}
}
else
{
foreach (var spec in massSpecDataReader.ReadAllSpectra())
{
progressData.Report(trackingInfo.SpecRead, trackingInfo.NumSpectra);
HandleSpectrum(ref trackingInfo, isolationMzBinToScanNums, spec);
}
}
progressData.Status = "Processing Isolation Bins";
progressData.IsPartialRange = false;
progressData.Report(95.1);
foreach (var entry in isolationMzBinToScanNums)
{
var binNum = entry.Key;
entry.Value.Sort();
var scanNumList = entry.Value.ToArray();
IsolationMzBinToScanNums[binNum] = scanNumList;
}
_ms1PeakList.Sort();
//_ms2PeakList.Sort();
progressData.Report(99.5);
// Read MS levels and precursor information
MinLcScan = trackingInfo.MinScanNum;
MaxLcScan = trackingInfo.MaxScanNum;
MinMsLevel = trackingInfo.MinMsLevel;
MaxMsLevel = trackingInfo.MaxMsLevel;
//var precursorMap = new Dictionary<int, int>();
//var nextScanMap = new Dictionary<int, int>();
//
//for (var msLevel = MinMsLevel; msLevel <= maxMsLevel; msLevel++)
//{
// precursorMap[msLevel] = 0;
// nextScanMap[msLevel] = MaxLcScan + 1;
//}
//progressData.Report(99.8);
progressData.Report(100.0);
CreatePrecursorNextScanMap();
}