private bool NextSpectrumIsAgilentMse(MsDataSpectrum nextSpectrum, int listLevel, double startCE)
{
// Average runs of MS/MS scans until the start CE is seen again
return (_filter.IsAgilentMse &&
listLevel == 2 &&
nextSpectrum.Level == 2 &&
startCE != GetPrecursorCollisionEnergy(nextSpectrum));
}
/// <summary>
/// generates a fake deconvolution solution for the given test spectrum
/// in order to make sure that the deconvolution results are being applied
/// correctly to scale peaks in the test spectrum
/// </summary>
private static void TestPeakIntensityCorrection(MsDataSpectrum testSpectrum,
AbstractIsoWindowMapper isoMapper,
AbstractDemultiplexer demultiplexer)
{
// Store a reference to the old spectrum processor
var oldProcessor = demultiplexer.SpectrumProcessor;
MsxDeconvSolverHandler db = new MsxDeconvSolverHandler(100, 120, 35);
int[] isoIndices;
int[] deconvIndices;
double[] mask = new double[100];
isoMapper.GetWindowMask(testSpectrum, out isoIndices, out deconvIndices, ref mask);
db.SetDeconvIndices(deconvIndices);
Assert.IsTrue(deconvIndices.Contains(50));
Assert.IsTrue(deconvIndices.Contains(47));
Assert.IsTrue(deconvIndices.Contains(15));
Assert.IsTrue(deconvIndices.Contains(17));
Assert.IsTrue(deconvIndices.Contains(74));
Assert.AreEqual(5, deconvIndices.Length);
// Prepare the transition binner with a precursor containing transitions overlapping
// peaks in the test spectrum
List<double> precursors = new List<double>();
List<KeyValuePair<double, double>> transitions = new List<KeyValuePair<double, double>>();
var precVals = new[] {710.57};
var transMzs = new[] {372.18, 373.1588, 373.1794, 375.2, 379.23, 387.19};
var transWidths = new[] {0.3, 0.04, 0.02, 1.0, 1.0, 1.0};
foreach (var precMz in precVals)
{
for (int i = 0; i < isoIndices.Length; ++i)
{
var transMz = transMzs[i];
var transWidth = transWidths[i];
precursors.Add(precMz);
transitions.Add(new KeyValuePair<double, double>(transMz, transWidth));
}
}
var transBinner = new TransitionBinner(precursors, transitions, isoMapper);
var binIndicesSet = new HashSet<int>(transBinner.BinsForDeconvWindows(deconvIndices));
double[][] deconvIntensities = new double[deconvIndices.Length][];
double[][] deconvMzs = new double[deconvIndices.Length][];
for (int i = 0; i < deconvIndices.Length; ++i)
{
deconvIntensities[i] = new double[testSpectrum.Mzs.Length];
deconvMzs[i] = new double[testSpectrum.Mzs.Length];
}
List<int> binIndicesList = binIndicesSet.ToList();
binIndicesList.Sort();
// Use each transition bin index to test a different possible
// type of demultiplexed solution
int numDeMultiplexedTrans = binIndicesSet.Count;
double[] peakSums = new double[numDeMultiplexedTrans];
// Initialize the deconvBlock
db.Solution.Resize(100, binIndicesList.Count);
db.Solution.Clear();
// Transition index 0, each row is a precursor
// the values for each precursor are the relative contribution
// of that precursor to the observed (convolved) intensity of the peak
db.Solution.Matrix[2, 0] = 0.0;
db.Solution.Matrix[1, 0] = 0.0;
db.Solution.Matrix[0, 0] = 0.0;
db.Solution.Matrix[3, 0] = 0.0;
db.Solution.Matrix[4, 0] = 0.0;
peakSums[0] = 0.0;
// Transition index 1, each row is a precursor
db.Solution.Matrix[2, 1] = 1.0;
db.Solution.Matrix[1, 1] = 1.0;
db.Solution.Matrix[0, 1] = 2.0;
db.Solution.Matrix[3, 1] = 1.0;
db.Solution.Matrix[4, 1] = 1.0;
peakSums[1] = 6.0;
// Transition index 2, each row is a precursor
db.Solution.Matrix[2, 2] = 2.0;
db.Solution.Matrix[1, 2] = 1.0;
db.Solution.Matrix[0, 2] = 3.0;
db.Solution.Matrix[3, 2] = 3.0;
db.Solution.Matrix[4, 2] = 1.0;
peakSums[2] = 10.0;
// Transition index 3, each row is a precursor
db.Solution.Matrix[2, 3] = 0.0;
db.Solution.Matrix[1, 3] = 0.0;
db.Solution.Matrix[0, 3] = 1.0;
db.Solution.Matrix[3, 3] = 0.0;
db.Solution.Matrix[4, 3] = 0.0;
peakSums[3] = 1.0;
// Transition index 4, each row is a precursor
db.Solution.Matrix[2, 4] = 1.0;
db.Solution.Matrix[1, 4] = 1.0;
db.Solution.Matrix[0, 4] = 1.0;
db.Solution.Matrix[3, 4] = 1.0;
db.Solution.Matrix[4, 4] = 1.0;
peakSums[4] = 5.0;
// Transition bin index (in transBinner) -> solution transition index (0-4 above), needed for
// CorrectPeakIntensities call
Dictionary<int, int> binToDeconvIndex = new Dictionary<int, int>(numDeMultiplexedTrans);
int numBinIndices = binIndicesList.Count;
for (int i = 0; i < numBinIndices; ++i)
binToDeconvIndex[binIndicesList[i]] = i;
var queryBinEnumerator = transBinner.BinsFromValues(testSpectrum.Mzs, true);
demultiplexer.SpectrumProcessor = new SpectrumProcessor(165, isoMapper, transBinner);
// Apply the peak intensity correction
demultiplexer.CorrectPeakIntensitiesTest(testSpectrum, binIndicesSet, peakSums,
queryBinEnumerator, db, ref deconvIntensities,
ref deconvMzs);
// Check that the five solutions defined above were applied correctly
// by CorrectPeakIntensities
// If all precursors contribute 0 intensity, the peak should be zero for every
// deconvolved spectrum
for (int i = 0; i < deconvIndices.Length; ++i)
{
Assert.AreEqual(deconvIntensities[i][binToDeconvIndex[0]], 0.0);
}
// Find the index of the demultiplexed spectrum corresponding to the precursor
// at 710.57 m/z for which we generated the dummy demultiplexing solution for
int windowIndex;
isoMapper.TryGetDeconvFromMz(710.57, out windowIndex);
Assert.AreEqual(50, windowIndex);
int isoIndex = deconvIndices.IndexOf(i => i == windowIndex);
Assert.AreNotEqual(-1 , isoIndex);
// This peak falls in one transition bin (transition index 1)
// 47 is the index of a peak in the test spectrum
var originalIntensity = testSpectrum.Intensities[47];
var expectedIntensity = originalIntensity*(2.0/6.0);
Assert.AreEqual(deconvIntensities[isoIndex][47], expectedIntensity, 0.00001);
// This peak falls in one transitions bin (transition index 2)
originalIntensity = testSpectrum.Intensities[50];
expectedIntensity = originalIntensity*(3.0/10.0);
Assert.AreEqual(deconvIntensities[isoIndex][50], expectedIntensity, 0.00001);
// This peak falls in both transition indices 1 and 2, the expected adjusted
// intensity should be the average of the solution from each transition bin
originalIntensity = testSpectrum.Intensities[49];
expectedIntensity = originalIntensity*(19.0/60.0);
Assert.AreEqual(deconvIntensities[isoIndex][49], expectedIntensity, 0.00001);
// This peak falls in transition index 3, and the demultiplexing spectra
// indicates that all of the intensity of teh original peak comes from
// the precursor window at isoIndex that's being queried. The peak intensity
// should not change
originalIntensity = testSpectrum.Intensities[108];
expectedIntensity = originalIntensity;
Assert.AreEqual(deconvIntensities[isoIndex][108], expectedIntensity, 0.00001);
// This peak falls in one transition bin (transition index 5)
originalIntensity = testSpectrum.Intensities[149];
expectedIntensity = originalIntensity * (1.0/5.0);
Assert.AreEqual(deconvIntensities[isoIndex][149], expectedIntensity, 0.00001);
// Undo changes to the spectrum processor in case this demultiplexer object is
// reused
demultiplexer.SpectrumProcessor = oldProcessor;
}
private static double GetPrecursorCollisionEnergy(MsDataSpectrum dataSpectrum)
{
return dataSpectrum.Precursors.Length > 0
? dataSpectrum.Precursors[0].PrecursorCollisionEnergy ?? 0
: 0;
}
private static double FindMinMz(MsDataSpectrum[] spectra, int[] indices)
{
double minMz = double.MaxValue;
for (int i = 0; i < indices.Length; i++)
{
var scan = spectra[i];
int indexMz = indices[i];
if (indexMz < scan.Mzs.Length)
minMz = Math.Min(minMz, spectra[i].Mzs[indexMz]);
}
return minMz;
}
private void SetSpectra(MsDataSpectrum[] spectra)
{
Invoke(new Action(() => SetSpectraUI(spectra)));
}
/// <summary>
/// Process a list of spectra - typically of length one,
/// but possibly a set of drift bins all with same retention time,
/// or a set of Agilent ramped-CE Mse scans to be averaged
/// </summary>
private void ProcessSpectrumList(MsDataSpectrum[] spectra,
ChromDataCollectorSet chromMap,
double rt,
SpectrumFilter filter,
string scanId)
{
lock (_blockWriter)
{
foreach (var spectrum in filter.Extract(rt, spectra))
{
if (_loader.IsCanceled)
throw new LoadCanceledException(Status);
chromMap.ProcessExtractedSpectrum((float) rt, _collectors, GetScanIdIndex(scanId), spectrum, AddChromCollector);
}
}
}
public MsDataSpectrum GetSpectrum(int index)
{
if (index == _lookAheadIndex)
{
return _lookAheadDataSpectrum ?? (_lookAheadDataSpectrum = _dataFile.GetSpectrum(index));
}
else
{
return _dataFile.GetSpectrum(index);
}
}
private MsDataSpectrum GetSpectrum(Spectrum spectrum)
{
if (spectrum == null)
{
return new MsDataSpectrum
{
Centroided = true,
Mzs = new double[0],
Intensities = new double[0]
};
}
var msDataSpectrum = new MsDataSpectrum
{
Id = id.abbreviate(spectrum.id),
Level = GetMsLevel(spectrum) ?? 0,
Index = spectrum.index,
RetentionTime = GetStartTime(spectrum),
DriftTimeMsec = GetDriftTimeMsec(spectrum),
Precursors = GetPrecursors(spectrum),
Centroided = IsCentroided(spectrum),
};
if (spectrum.binaryDataArrays.Count <= 1)
{
msDataSpectrum.Mzs = new double[0];
msDataSpectrum.Intensities = new double[0];
}
else
{
try
{
msDataSpectrum.Mzs = ToArray(spectrum.getMZArray());
msDataSpectrum.Intensities = ToArray(spectrum.getIntensityArray());
if (msDataSpectrum.Level == 1 && _config.simAsSpectra &&
spectrum.scanList.scans[0].scanWindows.Count > 0)
{
msDataSpectrum.Precursors = GetMs1Precursors(spectrum);
}
return msDataSpectrum;
}
catch (NullReferenceException)
{
}
}
return msDataSpectrum;
}
public IEnumerable<ExtractedSpectrum> Extract(double? retentionTime, MsDataSpectrum[] spectra)
{
if (!EnabledMsMs || !retentionTime.HasValue || !spectra.Any())
yield break;
var handlingType = _fullScan.IsolationScheme == null || _fullScan.IsolationScheme.SpecialHandling == null
? IsolationScheme.SpecialHandlingType.NONE
: _fullScan.IsolationScheme.SpecialHandling;
bool ignoreIso = handlingType == IsolationScheme.SpecialHandlingType.OVERLAP ||
handlingType == IsolationScheme.SpecialHandlingType.OVERLAP_MULTIPLEXED;
foreach (var isoWin in GetIsolationWindows(spectra[0].Precursors))
{
foreach (var filterPair in FindFilterPairs(isoWin, _acquisitionMethod, ignoreIso))
{
if (!filterPair.ContainsRetentionTime(retentionTime.Value))
continue;
var filteredSrmSpectrum = filterPair.FilterQ3SpectrumList(spectra, _isWatersMse && GetMseLevel() > 1);
if (filteredSrmSpectrum != null)
yield return filteredSrmSpectrum;
}
}
}
public bool TryGetSpectrum(int scanNum, out MsDataSpectrum spectrum)
{
return _cache.TryGetValue(scanNum, out spectrum);
}
public bool IsWatersLockmassSpectrum(MsDataSpectrum s)
{
return _lockmassFunction.HasValue && (s.WatersFunctionNumber >= _lockmassFunction.Value);
}
public void Add(int scanNum, MsDataSpectrum s)
{
if (_scanStack.Count() >= _cacheSize)
{
_cache.Remove(_scanStack.Dequeue());
}
_cache.Add(scanNum, s);
_scanStack.Enqueue(scanNum);
}
private static TransitionBinner TestTransitionBinnerOverlap(MsDataSpectrum spectrum,
AbstractIsoWindowMapper isoMapper, double[] binnedIntensities)
{
// Multiple transitions overlapping the same peak from the same precursor
var precursorList = new List<double>();
var transitionList = new List<KeyValuePair<double, double>>();
precursorList.Add(710.5); //transition: start - stop index
transitionList.Add(new KeyValuePair<double, double>(380.19,1.0)); // 379.69-380.69 Bin3
precursorList.Add(710.5);
transitionList.Add(new KeyValuePair<double, double>(380.44,1.0)); // 379.94-380.94 Bin4
precursorList.Add(710.5);
transitionList.Add(new KeyValuePair<double, double>(380.49,0.6)); // 380.19-380.79 Bin5
// And a non-overlapping transition for good measure
precursorList.Add(710.5);
transitionList.Add(new KeyValuePair<double, double>(389.19,0.3)); // 389.04 - 389.34 Bin7
// And a transition that won't have any peaks in the spectrum
precursorList.Add(710.5);
transitionList.Add(new KeyValuePair<double, double>(377.0,0.7)); // 376.65-377.35 Bin0
// And now another precursor with some of the transitions overlapping the first
precursorList.Add(595.0);
transitionList.Add(new KeyValuePair<double, double>(380.0,1.0)); // 379.5 - 380.5 Bin2
precursorList.Add(595.0);
transitionList.Add(new KeyValuePair<double, double>(379.55,1.0)); // 379.05 - 380.05 Bin1
precursorList.Add(595.0);
transitionList.Add(new KeyValuePair<double, double>(389.15, 0.4)); // 388.95 - 389.35 Bin6
var transitionBinner = new TransitionBinner(precursorList, transitionList, isoMapper);
double[] binnedData = new double[transitionList.Count];
transitionBinner.BinData(spectrum.Mzs, spectrum.Intensities, ref binnedData);
// Test that m/z, intensity pairs were binned correctly into their transitions
for (int i = 0; i< binnedData.Length; ++i)
{
Assert.AreEqual(binnedIntensities[i], binnedData[i], 0.001);
}
// Get the precursor index for this precursor
// make sure the precursor -> transition mapping is working for the first precursor
int windowIndexOne;
Assert.IsTrue(isoMapper.TryGetDeconvFromMz(710.5, out windowIndexOne));
// Use the precursor index to get the bins mapping to this precursor
var precursorBins = new HashSet<int>(transitionBinner.BinsForDeconvWindows(new[] {windowIndexOne}));
var expectedPrecursorBins = new HashSet<int>(new[]{0,3,4,5,7});
var setComparer = HashSet<int>.CreateSetComparer();
Assert.IsTrue(setComparer.Equals(expectedPrecursorBins, precursorBins));
// Make sure the precursor -> transition mapping is working for the second precursor
int windowIndexTwo;
Assert.IsTrue(isoMapper.TryGetDeconvFromMz(595.0, out windowIndexTwo));
precursorBins = new HashSet<int>(transitionBinner.BinsForDeconvWindows(new[]{windowIndexOne, windowIndexTwo}));
expectedPrecursorBins = new HashSet<int>(new[]{0,1,2,3,4,5,6,7});
Assert.IsTrue(setComparer.Equals(expectedPrecursorBins, precursorBins));
// m/z values to test mapping of m/z value -> multiplex matching transition bins
var queryVals = new[] {252.0, 377.0, 379.92, 379.95};
var bins = transitionBinner.BinsFromValues(queryVals, true).ToList();
var expectedBins = new List<KeyValuePair<int, int>>
{
new KeyValuePair<int, int>(1, 0),
new KeyValuePair<int, int>(2, 1),
new KeyValuePair<int, int>(2, 2),
new KeyValuePair<int, int>(2, 3),
new KeyValuePair<int, int>(3, 1),
new KeyValuePair<int, int>(3, 2),
new KeyValuePair<int, int>(3, 3),
new KeyValuePair<int, int>(3, 4)
};
AssertEx.AreEqualDeep(expectedBins, bins);
Assert.AreEqual(376.65, transitionBinner.LowerValueFromBin(0),0.0001);
Assert.AreEqual(377.35, transitionBinner.UpperValueFromBin(0),0.0001);
Assert.AreEqual(377.0, transitionBinner.CenterValueFromBin(0),0.0001);
return transitionBinner;
}
/// <summary>
/// Demultiplexes a real .mxML file in a case where the answer is simple, and checks the answer is correct.
/// </summary>
private static void TestSpectrumDemultiplex(AbstractDemultiplexer demultiplexer,
int spectrumIndex,
MsDataSpectrum originalSpectrum,
int[] intensityIndices,
double[] intensityValues,
int deconvIndex)
{
var deconvSpectra = demultiplexer.GetDeconvolvedSpectra(spectrumIndex, originalSpectrum);
int numberMzPoints = originalSpectrum.Intensities.Length;
double[] peakSums = new double[numberMzPoints];
for (int i = 0; i < numberMzPoints; ++i)
{
peakSums[i] = 0.0;
}
foreach (var deconvSpectrum in deconvSpectra)
{
Assert.AreEqual(deconvSpectrum.Intensities.Length, originalSpectrum.Intensities.Length);
for (int i = 0; i < numberMzPoints; ++i)
{
peakSums[i] += deconvSpectrum.Intensities[i];
}
}
for (int i = 0; i < numberMzPoints; ++i)
{
Assert.AreEqual(peakSums[i], originalSpectrum.Intensities[i], 0.01);
}
for (int i = 0; i < intensityIndices.Length ; ++i)
{
Assert.AreEqual(deconvSpectra[deconvIndex].Intensities[intensityIndices[i]], intensityValues[i], 0.1);
}
}
private bool NextSpectrumIsDriftScanForCurrentRetentionTime(MsDataSpectrum nextSpectrum)
{
bool result = ((_rt ?? 0) == (nextSpectrum.RetentionTime ?? -1)) &&
((nextSpectrum.DriftTimeMsec ?? 0) > _previousDriftTime);
_previousDriftTime = nextSpectrum.DriftTimeMsec ?? 0;
return result;
}
public bool IsMsSpectrum(MsDataSpectrum dataSpectrum)
{
if (!EnabledMs)
return false;
if (_mseLevel > 0)
return UpdateMseLevel(dataSpectrum) == 1;
return dataSpectrum.Level == 1;
}
public SpectrumInfo(int index, MsDataSpectrum dataSpectrum, MsDataSpectrum[] allSpectra, double retentionTime)
{
Index = index;
DataSpectrum = dataSpectrum;
AllSpectra = allSpectra;
RetentionTime = retentionTime;
}
public bool IsSimSpectrum(MsDataSpectrum dataSpectrum)
{
if (!EnabledMs || _mseLevel > 0)
return false;
return dataSpectrum.Level == 1 &&
IsSimIsolation(GetIsolationWindows(dataSpectrum.Precursors).FirstOrDefault());
}
public LookaheadContext(SpectrumFilter filter, MsDataFileImpl dataFile)
{
_lookAheadIndex = 0;
_lookAheadDataSpectrum = null;
_filter = filter;
_dataFile = dataFile;
_rt = null;
_previousDriftTime = 0;
_lenSpectra = dataFile.SpectrumCount;
}
public IEnumerable<ExtractedSpectrum> SrmSpectraFromMs1Scan(double? retentionTime,
IList<MsPrecursor> precursors, MsDataSpectrum[] spectra)
{
if (!EnabledMs || !retentionTime.HasValue || spectra == null)
yield break;
// All filter pairs have a shot at filtering the MS1 scans
bool isSimSpectra = spectra.Any(IsSimSpectrum);
foreach (var filterPair in FindMs1FilterPairs(precursors))
{
if (!filterPair.ContainsRetentionTime(retentionTime.Value))
continue;
var filteredSrmSpectrum = filterPair.FilterQ1SpectrumList(spectra, isSimSpectra);
if (filteredSrmSpectrum != null)
yield return filteredSrmSpectrum;
}
}
// Deal with ion mobility data - look ahead for a run of scans all
// with the same retention time. For non-IMS data we'll just get
// a single "drift bin" with no drift time.
//
// Also for Agilent ramped-CE msE, gather MS2 scans together
// so they get averaged.
public MsDataSpectrum[] Lookahead(MsDataSpectrum dataSpectrum, out double? rt)
{
var spectrumList = new List<MsDataSpectrum>();
int listLevel = dataSpectrum.Level;
double startCE = GetPrecursorCollisionEnergy(dataSpectrum);
_previousDriftTime = -1;
double rtTotal = 0;
double? rtFirst = null;
_lookAheadDataSpectrum = null;
while (_lookAheadIndex++ < _lenSpectra)
{
_rt = dataSpectrum.RetentionTime;
if (_rt.HasValue && dataSpectrum.Mzs.Length != 0)
{
spectrumList.Add(dataSpectrum);
rtTotal += dataSpectrum.RetentionTime.Value;
if (!rtFirst.HasValue)
rtFirst = dataSpectrum.RetentionTime;
}
if (!_filter.IsAgilentMse && !dataSpectrum.DriftTimeMsec.HasValue)
break;
if (_lookAheadIndex < _lenSpectra)
{
dataSpectrum = _lookAheadDataSpectrum = _dataFile.GetSpectrum(_lookAheadIndex);
// Reasons to keep adding to the list:
// Retention time hasn't changed but drift time has increased, or
// Agilent ramped-CE data - MS2 scans get averaged
if (!(NextSpectrumIsDriftScanForCurrentRetentionTime(dataSpectrum) ||
NextSpectrumIsAgilentMse(dataSpectrum, listLevel, startCE)))
break;
}
}
if (spectrumList.Any()) // Should have at least one non-empty scan at this drift time
_rt = _filter.IsAgilentMse ? (rtTotal / spectrumList.Count()) : rtFirst;
else
_rt = null;
rt = _rt;
return spectrumList.ToArray();
}
private int UpdateMseLevel(MsDataSpectrum dataSpectrum)
{
int returnval;
if ((_mseLastSpectrum == null) || !ReferenceEquals(dataSpectrum, _mseLastSpectrum)) // is this the same one we were just asked about?
{
// Waters MSe is enumerated in interleaved scans ("functions" in the raw data) 1==MS 2==MSMS 3=ignore
// Bruker MSe is enumerated in interleaved MS1 and MS/MS scans
// Agilent MSe is a series of MS1 scans with ramped CE (SpectrumList_Agilent returns these as MS1,MS2,MS2,...)
// but with ion mobility, as of June 2014, it's just a series of MS2 scans with a single nonzero CE, or MS1 scans with 0 CE
if (_isAgilentMse)
{
if (1 == dataSpectrum.Level)
{
_mseLevel = 1; // Expecting a series of MS2 scans to follow after this
returnval = 1; // Report as MS1
}
else if ((2 == dataSpectrum.Level) &&
(_mseLastSpectrum != null)) // Sometimes the file doesn't contain that leading MS1 scan
{
_mseLevel = 2;
returnval = 2;
}
else
{
returnval = 0; // Not useful - probably the file started off mid-cycle, with MS2 CE>0
}
}
else if (!_isWatersMse)
{
// Bruker - Alternate between 1 and 2
_mseLevel = (_mseLevel % 2) + 1;
returnval = _mseLevel;
}
else
{
// Waters - mse level 1 in raw data "function 1", mse level 2 in raw data "function 2", and "function 3" which we ignore (lockmass?)
// All are declared mslevel=1, but we can tell these apart by inspecting the Id which is formatted as <function>.<process>.<scan>
_mseLevel = int.Parse(dataSpectrum.Id.Split('.')[0]);
returnval = _mseLevel;
}
_mseLastSpectrumLevel = returnval;
}
else
{
returnval = _mseLastSpectrumLevel; // we were just asked about this spectrum, no update this time
}
_mseLastSpectrum = dataSpectrum;
return returnval;
}
private static double SumIntensities(MsDataSpectrum[] spectra, double mz, int[] indices)
{
double intensity = 0;
for (int i = 0; i < indices.Length; i++)
{
var scan = spectra[i];
int indexMz;
// Sometimes spectra have multiple intensities for a given m/z. Sum all intensities for that m/z
for (indexMz = indices[i]; indexMz < scan.Mzs.Length && scan.Mzs[indexMz] == mz; indexMz++)
{
intensity += scan.Intensities[indexMz];
}
indices[i] = indexMz;
}
return intensity;
}
public int NextIndex(int proposed)
{
if (_lookAheadIndex <= proposed)
{
_lookAheadIndex = proposed + 1;
_lookAheadDataSpectrum = null;
}
return _lookAheadIndex;
}
private void SetSpectraUI(MsDataSpectrum[] spectra)
{
_msDataFileScanHelper.MsDataSpectra = spectra;
_heatMapData = null;
if (_msDataFileScanHelper.MsDataSpectra == null)
return;
// Find max values.
_maxMz = 0;
_maxIntensity = 0;
GetMaxMzIntensity(out _maxMz, out _maxIntensity);
_maxDriftTime = 0;
foreach (var spectrum in spectra)
_maxDriftTime = Math.Max(_maxDriftTime, spectrum.DriftTimeMsec ?? 0);
if (_zoomXAxis)
{
_zoomXAxis = false;
ZoomXAxis();
}
if (_zoomYAxis)
{
_zoomYAxis = false;
ZoomYAxis();
}
CreateGraph();
UpdateUI();
}
private void SetScans(MsDataSpectrum[] scans)
{
lock (this)
{
_msDataFileScanHelper.MsDataSpectra = scans;
Monitor.PulseAll(this);
}
}
