/// <summary> /// Searches currentScan.IonsMZ for the maximum intensity value between mzStart and mzEnd /// If a match is found, updates bestMatchMZ to the m/z of the match, /// updates matchIntensity to its intensity, and returns True /// </summary> /// <param name="spectraCache"></param> /// <param name="currentScan"></param> /// <param name="mzStart"></param> /// <param name="mzEnd"></param> /// <param name="bestMatchMZ">Output: m/z of the most intense ion in the given range</param> /// <param name="matchIntensity">Output: intensity of the most intense ion in the given range</param> /// <returns>True if a match is found, false if no data exists within the m/z range (or if the spectrum could not be obtained)</returns> /// <remarks> /// Note that this function performs a linear search of .IonsMZ /// It is therefore good for spectra with less than 10 data points and bad for spectra with more than 10 data points /// As an alternative to this function, use AggregateIonsInRange /// </remarks> public bool FindMaxValueInMZRange( clsSpectraCache spectraCache, clsScanInfo currentScan, double mzStart, double mzEnd, out double bestMatchMZ, out double matchIntensity) { bestMatchMZ = 0; matchIntensity = 0; try { if (!spectraCache.GetSpectrum(currentScan.ScanNumber, out var spectrum, true)) { OnErrorEvent("Error uncaching scan " + currentScan.ScanNumber); return(false); } var success = FindMaxValueInMZRange( spectrum.IonsMZ, spectrum.IonsIntensity, spectrum.IonCount, mzStart, mzEnd, out bestMatchMZ, out matchIntensity); return(success); } catch (Exception ex) { OnErrorEvent("Error in FindMaxValueInMZRange (A): " + ex.Message, ex); return(false); } }
private clsScanInfo GetFakeSurveyScan(int scanNumber, float scanTime) { var surveyScan = new clsScanInfo() { ScanNumber = scanNumber, ScanTime = scanTime, ScanHeaderText = "Full ms", ScanTypeName = "MS", BasePeakIonMZ = 0, BasePeakIonIntensity = 0, TotalIonIntensity = 0, ZoomScan = false, SIMScan = false, MRMScanType = MRMScanTypeConstants.NotMRM, LowMass = 0, HighMass = 0, IsFTMS = false }; // Survey scans typically lead to multiple parent ions; we do not record them here surveyScan.FragScanInfo.ParentIonInfoIndex = -1; // Store the collision mode and possibly the scan filter text surveyScan.FragScanInfo.CollisionMode = string.Empty; return(surveyScan); }
/// <summary> /// Centroid a profile mode spectrum using the ThermoFisher.CommonCore.Data centroiding logic /// </summary> /// <param name="scanInfo"></param> /// <param name="masses"></param> /// <param name="intensities"></param> /// <param name="centroidedPrecursorIonsMz"></param> /// <param name="centroidedPrecursorIonsIntensity"></param> /// <returns></returns> public bool CentroidData(clsScanInfo scanInfo, double[] masses, double[] intensities, out double[] centroidedPrecursorIonsMz, out double[] centroidedPrecursorIonsIntensity) { const double massResolution = 10000; return(CentroidData(scanInfo, masses, intensities, massResolution, out centroidedPrecursorIonsMz, out centroidedPrecursorIonsIntensity)); }
/// <summary> /// Centroid a profile mode spectrum using the ThermoFisher.CommonCore.Data centroiding logic /// </summary> /// <param name="scanInfo"></param> /// <param name="masses"></param> /// <param name="intensities"></param> /// <param name="centroidedPrecursorIonsMz"></param> /// <param name="centroidedPrecursorIonsIntensity"></param> /// <returns></returns> public bool CentroidData( clsScanInfo scanInfo, double[] masses, double[] intensities, double massResolution, out double[] centroidedPrecursorIonsMz, out double[] centroidedPrecursorIonsIntensity) { try { var segmentedScan = ThermoFisher.CommonCore.Data.Business.SegmentedScan.FromMassesAndIntensities(masses, intensities); var scanStats = new ThermoFisher.CommonCore.Data.Business.ScanStatistics() { PacketType = 2 + (2 << 16), ScanNumber = scanInfo.ScanNumber, StartTime = scanInfo.ScanTime, BasePeakIntensity = scanInfo.BasePeakIonIntensity, BasePeakMass = scanInfo.BasePeakIonMZ, LowMass = masses.First(), HighMass = masses.Last(), TIC = scanInfo.TotalIonIntensity }; var scan = new ThermoFisher.CommonCore.Data.Business.Scan() { MassResolution = massResolution, ScanType = scanInfo.ScanTypeName, ToleranceUnit = ThermoFisher.CommonCore.Data.Business.ToleranceMode.Ppm, // Options are None, Amu, Mmu, Ppm ScanStatistics = scanStats, SegmentedScan = segmentedScan }; var centroidScan = ThermoFisher.CommonCore.Data.Business.Scan.ToCentroid(scan); centroidedPrecursorIonsMz = centroidScan.PreferredMasses; centroidedPrecursorIonsIntensity = centroidScan.PreferredIntensities; return(true); } catch (Exception ex) { centroidedPrecursorIonsMz = new double[1]; centroidedPrecursorIonsIntensity = new double[1]; return(false); } }
private void ComputeNoiseLevelForMassSpectrum( clsScanInfo scanInfo, clsMSSpectrum msSpectrum, clsBaselineNoiseOptions noiseThresholdOptions) { const bool IGNORE_NON_POSITIVE_DATA = true; scanInfo.BaselineNoiseStats = clsMASICPeakFinder.InitializeBaselineNoiseStats(0, noiseThresholdOptions.BaselineNoiseMode); if (noiseThresholdOptions.BaselineNoiseMode == clsMASICPeakFinder.eNoiseThresholdModes.AbsoluteThreshold) { scanInfo.BaselineNoiseStats.NoiseLevel = noiseThresholdOptions.BaselineNoiseLevelAbsolute; scanInfo.BaselineNoiseStats.PointsUsed = 1; } else if (msSpectrum.IonCount > 0) { mPeakFinder.ComputeTrimmedNoiseLevel( msSpectrum.IonsIntensity, 0, msSpectrum.IonCount - 1, noiseThresholdOptions, IGNORE_NON_POSITIVE_DATA, out var newBaselineNoiseStats); scanInfo.BaselineNoiseStats = newBaselineNoiseStats; } }
public void TestScanConversions() { const double MZ_MINIMUM = 100; const float INTENSITY_MINIMUM = 10000; const float SCAN_TIME_SCALAR = 10; var scanList = new clsScanList(); var oRand = new Random(); var intLastSurveyScanIndexInMasterSeqOrder = -1; // Populate scanList with example scan data for (var scanNumber = 1; scanNumber <= 1750; scanNumber++) { if (scanNumber % 10 == 0) { // Add a survey scan // If this is a mzXML file that was processed with ReadW, .ScanHeaderText and .ScanTypeName will get updated by UpdateMSXMLScanType var newSurveyScan = new MASIC.clsScanInfo { ScanNumber = scanNumber, ScanTime = scanNumber / SCAN_TIME_SCALAR, ScanHeaderText = string.Empty, ScanTypeName = "MS", BasePeakIonMZ = MZ_MINIMUM + oRand.NextDouble() * 1000, BasePeakIonIntensity = INTENSITY_MINIMUM + (float)oRand.NextDouble() * 1000 }; // Survey scans typically lead to multiple parent ions; we do not record them here newSurveyScan.FragScanInfo.ParentIonInfoIndex = -1; newSurveyScan.TotalIonIntensity = newSurveyScan.BasePeakIonIntensity * (float)(0.25 + oRand.NextDouble() * 5); // Determine the minimum positive intensity in this scan newSurveyScan.MinimumPositiveIntensity = INTENSITY_MINIMUM; // If this is a mzXML file that was processed with ReadW, then these values will get updated by UpdateMSXMLScanType newSurveyScan.ZoomScan = false; newSurveyScan.SIMScan = false; newSurveyScan.MRMScanType = MRMScanTypeConstants.NotMRM; newSurveyScan.LowMass = MZ_MINIMUM; newSurveyScan.HighMass = Math.Max(newSurveyScan.BasePeakIonMZ * 1.1, MZ_MINIMUM * 10); newSurveyScan.IsFTMS = false; scanList.SurveyScans.Add(newSurveyScan); var intLastSurveyScanIndex = scanList.SurveyScans.Count - 1; scanList.AddMasterScanEntry(clsScanList.eScanTypeConstants.SurveyScan, intLastSurveyScanIndex); intLastSurveyScanIndexInMasterSeqOrder = scanList.MasterScanOrderCount - 1; } else { // If this is a mzXML file that was processed with ReadW, .ScanHeaderText and .ScanTypeName will get updated by UpdateMSXMLScanType var newFragScan = new MASIC.clsScanInfo { ScanNumber = scanNumber, ScanTime = scanNumber / SCAN_TIME_SCALAR, ScanHeaderText = string.Empty, ScanTypeName = "MSn", BasePeakIonMZ = MZ_MINIMUM + oRand.NextDouble() * 1000, BasePeakIonIntensity = INTENSITY_MINIMUM + (float)oRand.NextDouble() * 1000 }; // 1 for the first MS/MS scan after the survey scan, 2 for the second one, etc. newFragScan.FragScanInfo.FragScanNumber = (scanList.MasterScanOrderCount - 1) - intLastSurveyScanIndexInMasterSeqOrder; newFragScan.FragScanInfo.MSLevel = 2; newFragScan.TotalIonIntensity = newFragScan.BasePeakIonIntensity * (float)(0.25 + oRand.NextDouble() * 2); // Determine the minimum positive intensity in this scan newFragScan.MinimumPositiveIntensity = INTENSITY_MINIMUM; // If this is a mzXML file that was processed with ReadW, then these values will get updated by UpdateMSXMLScanType newFragScan.ZoomScan = false; newFragScan.SIMScan = false; newFragScan.MRMScanType = MRMScanTypeConstants.NotMRM; newFragScan.MRMScanInfo.MRMMassCount = 0; newFragScan.LowMass = MZ_MINIMUM; newFragScan.HighMass = Math.Max(newFragScan.BasePeakIonMZ * 1.1, MZ_MINIMUM * 10); newFragScan.IsFTMS = false; scanList.FragScans.Add(newFragScan); scanList.AddMasterScanEntry(clsScanList.eScanTypeConstants.FragScan, scanList.FragScans.Count - 1); } } var scanNumScanConverter = new clsScanNumScanTimeConversion(); RegisterEvents(scanNumScanConverter); // Convert absolute values // Scan 500, relative scan 0.5, and the scan at 30 minutes TestScanConversionToAbsolute( scanList, scanNumScanConverter, new KeyValuePair <int, int>(500, 500), new KeyValuePair <float, float>(0.5F, 876), new KeyValuePair <float, float>(30, 300)); TestScanConversionToTime( scanList, scanNumScanConverter, new KeyValuePair <int, int>(500, 50), new KeyValuePair <float, float>(0.5F, 87.55F), new KeyValuePair <float, float>(30, 30)); // Convert ranges // 50 scans wide, 10% of the run, and 5 minutes TestScanConversionToAbsolute( scanList, scanNumScanConverter, new KeyValuePair <int, int>(50, 50), new KeyValuePair <float, float>(0.1F, 176), new KeyValuePair <float, float>(5, 50)); TestScanConversionToTime( scanList, scanNumScanConverter, new KeyValuePair <int, int>(50, 5), new KeyValuePair <float, float>(0.1F, 17.59F), new KeyValuePair <float, float>(5, 5)); }
/// <summary> /// Looks for the reporter ion m/z values, +/- a tolerance /// Calls AggregateIonsInRange with returnMax = True, meaning we're reporting the maximum ion abundance for each reporter ion m/z /// </summary> /// <param name="rawFileReader"></param> /// <param name="dataAggregation"></param> /// <param name="includeFtmsColumns"></param> /// <param name="sicOptions"></param> /// <param name="scanList"></param> /// <param name="spectraCache"></param> /// <param name="currentScan"></param> /// <param name="writer"></param> /// <param name="reporterIons"></param> /// <param name="delimiter"></param> /// <param name="saveUncorrectedIntensities"></param> /// <param name="saveObservedMasses"></param> /// <remarks></remarks> private void FindReporterIonsWork( XRawFileIO rawFileReader, clsDataAggregation dataAggregation, bool includeFtmsColumns, clsSICOptions sicOptions, clsScanList scanList, clsSpectraCache spectraCache, clsScanInfo currentScan, TextWriter writer, IList <clsReporterIonInfo> reporterIons, char delimiter, bool saveUncorrectedIntensities, bool saveObservedMasses) { const bool USE_MAX_ABUNDANCE_IN_WINDOW = true; // The following will be a value between 0 and 100 // Using Absolute Value of percent change to avoid averaging both negative and positive values double parentIonMZ; if (currentScan.FragScanInfo.ParentIonInfoIndex >= 0 && currentScan.FragScanInfo.ParentIonInfoIndex < scanList.ParentIons.Count) { parentIonMZ = scanList.ParentIons[currentScan.FragScanInfo.ParentIonInfoIndex].MZ; } else { parentIonMZ = 0; } if (!spectraCache.GetSpectrum(currentScan.ScanNumber, out var spectrum, true)) { SetLocalErrorCode(clsMASIC.eMasicErrorCodes.ErrorUncachingSpectrum); return; } // Initialize the arrays used to track the observed reporter ion values var reporterIntensities = new double[reporterIons.Count]; var reporterIntensitiesCorrected = new double[reporterIons.Count]; var closestMZ = new double[reporterIons.Count]; // Initialize the output variables var dataColumns = new List <string>() { sicOptions.DatasetID.ToString(), currentScan.ScanNumber.ToString(), currentScan.FragScanInfo.CollisionMode, StringUtilities.DblToString(parentIonMZ, 2), StringUtilities.DblToString(currentScan.BasePeakIonIntensity, 2), StringUtilities.DblToString(currentScan.BasePeakIonMZ, 4) }; var reporterIntensityList = new List <string>(reporterIons.Count); var obsMZList = new List <string>(reporterIons.Count); var uncorrectedIntensityList = new List <string>(reporterIons.Count); var ftmsSignalToNoise = new List <string>(reporterIons.Count); var ftmsResolution = new List <string>(reporterIons.Count); //var ftmsLabelDataMz = new List<string>(reporterIons.Count); double reporterIntensityMax = 0; // Find the reporter ion intensities // Also keep track of the closest m/z for each reporter ion // Note that we're using the maximum intensity in the range (not the sum) for (var reporterIonIndex = 0; reporterIonIndex < reporterIons.Count; reporterIonIndex++) { var ion = reporterIons[reporterIonIndex]; // Search for the reporter ion MZ in this mass spectrum reporterIntensities[reporterIonIndex] = dataAggregation.AggregateIonsInRange( spectrum, ion.MZ, ion.MZToleranceDa, out _, out closestMZ[reporterIonIndex], USE_MAX_ABUNDANCE_IN_WINDOW); ion.SignalToNoise = 0; ion.Resolution = 0; ion.LabelDataMZ = 0; } if (includeFtmsColumns && currentScan.IsFTMS) { // Retrieve the label data for this spectrum rawFileReader.GetScanLabelData(currentScan.ScanNumber, out var ftLabelData); // Find each reporter ion in ftLabelData for (var reporterIonIndex = 0; reporterIonIndex < reporterIons.Count; reporterIonIndex++) { var mzToFind = reporterIons[reporterIonIndex].MZ; var mzToleranceDa = reporterIons[reporterIonIndex].MZToleranceDa; var highestIntensity = 0.0; var udtBestMatch = new udtFTLabelInfoType(); var matchFound = false; foreach (var labelItem in ftLabelData) { // Compare labelItem.Mass (which is m/z of the ion in labelItem) to the m/z of the current reporter ion if (Math.Abs(mzToFind - labelItem.Mass) > mzToleranceDa) { continue; } // m/z is within range if (labelItem.Intensity > highestIntensity) { udtBestMatch = labelItem; highestIntensity = labelItem.Intensity; matchFound = true; } } if (matchFound) { reporterIons[reporterIonIndex].SignalToNoise = udtBestMatch.SignalToNoise; reporterIons[reporterIonIndex].Resolution = udtBestMatch.Resolution; reporterIons[reporterIonIndex].LabelDataMZ = udtBestMatch.Mass; } } } // Populate reporterIntensitiesCorrected with the data in reporterIntensities Array.Copy(reporterIntensities, reporterIntensitiesCorrected, reporterIntensities.Length); if (mOptions.ReporterIons.ReporterIonApplyAbundanceCorrection) { if (mOptions.ReporterIons.ReporterIonMassMode == clsReporterIons.eReporterIonMassModeConstants.ITraqFourMZ || mOptions.ReporterIons.ReporterIonMassMode == clsReporterIons.eReporterIonMassModeConstants.ITraqEightMZHighRes || mOptions.ReporterIons.ReporterIonMassMode == clsReporterIons.eReporterIonMassModeConstants.ITraqEightMZLowRes || mOptions.ReporterIons.ReporterIonMassMode == clsReporterIons.eReporterIonMassModeConstants.TMTTenMZ || mOptions.ReporterIons.ReporterIonMassMode == clsReporterIons.eReporterIonMassModeConstants.TMTElevenMZ || mOptions.ReporterIons.ReporterIonMassMode == clsReporterIons.eReporterIonMassModeConstants.TMTSixteenMZ) { // Correct the reporter ion intensities using the Reporter Ion Intensity Corrector class if (intensityCorrector.ReporterIonMode != mOptions.ReporterIons.ReporterIonMassMode || intensityCorrector.ITraq4PlexCorrectionFactorType != mOptions.ReporterIons.ReporterIonITraq4PlexCorrectionFactorType) { intensityCorrector.UpdateReporterIonMode( mOptions.ReporterIons.ReporterIonMassMode, mOptions.ReporterIons.ReporterIonITraq4PlexCorrectionFactorType); } // Count the number of non-zero data points in reporterIntensitiesCorrected() var positiveCount = 0; for (var reporterIonIndex = 0; reporterIonIndex < reporterIons.Count; reporterIonIndex++) { if (reporterIntensitiesCorrected[reporterIonIndex] > 0) { positiveCount += 1; } } // Apply the correction if 2 or more points are non-zero if (positiveCount >= 2) { intensityCorrector.ApplyCorrection(reporterIntensitiesCorrected); } } } // Now construct the string of intensity values, delimited by delimiter // Will also compute the percent change in intensities // Initialize the variables used to compute the weighted average percent change double pctChangeSum = 0; double originalIntensitySum = 0; for (var reporterIonIndex = 0; reporterIonIndex < reporterIons.Count; reporterIonIndex++) { if (!reporterIons[reporterIonIndex].ContaminantIon) { // Update the PctChange variables and the IntensityMax variable only if this is not a Contaminant Ion originalIntensitySum += reporterIntensities[reporterIonIndex]; if (reporterIntensities[reporterIonIndex] > 0) { // Compute the percent change, then update pctChangeSum var pctChange = (reporterIntensitiesCorrected[reporterIonIndex] - reporterIntensities[reporterIonIndex]) / reporterIntensities[reporterIonIndex]; // Using Absolute Value here to prevent negative changes from cancelling out positive changes pctChangeSum += Math.Abs(pctChange * reporterIntensities[reporterIonIndex]); } if (reporterIntensitiesCorrected[reporterIonIndex] > reporterIntensityMax) { reporterIntensityMax = reporterIntensitiesCorrected[reporterIonIndex]; } } if (!reporterIons[reporterIonIndex].ContaminantIon || saveUncorrectedIntensities) { // Append the reporter ion intensity to reporterIntensityList // We skip contaminant ions, unless saveUncorrectedIntensities is True, then we include them reporterIntensityList.Add(StringUtilities.DblToString(reporterIntensitiesCorrected[reporterIonIndex], 2)); if (saveObservedMasses) { // Append the observed reporter mass value to obsMZList obsMZList.Add(StringUtilities.DblToString(closestMZ[reporterIonIndex], 3)); } if (saveUncorrectedIntensities) { // Append the original, uncorrected intensity value uncorrectedIntensityList.Add(StringUtilities.DblToString(reporterIntensities[reporterIonIndex], 2)); } if (includeFtmsColumns) { if (Math.Abs(reporterIons[reporterIonIndex].SignalToNoise) < float.Epsilon && Math.Abs(reporterIons[reporterIonIndex].Resolution) < float.Epsilon && Math.Abs(reporterIons[reporterIonIndex].LabelDataMZ) < float.Epsilon) { // A match was not found in the label data; display blanks (not zeroes) ftmsSignalToNoise.Add(string.Empty); ftmsResolution.Add(string.Empty); //ftmsLabelDataMz.Add(string.Empty); } else { ftmsSignalToNoise.Add(StringUtilities.DblToString(reporterIons[reporterIonIndex].SignalToNoise, 2)); ftmsResolution.Add(StringUtilities.DblToString(reporterIons[reporterIonIndex].Resolution, 2)); //ftmsLabelDataMz.Add(StringUtilities.DblToString(reporterIons(reporterIonIndex).LabelDataMZ, 4)); } } } } // Compute the weighted average percent intensity correction value float weightedAvgPctIntensityCorrection; if (originalIntensitySum > 0) { weightedAvgPctIntensityCorrection = (float)(pctChangeSum / originalIntensitySum * 100); } else { weightedAvgPctIntensityCorrection = 0; } // Resize the target list capacity to large enough to hold all data. dataColumns.Capacity = reporterIntensityList.Count + 3 + obsMZList.Count + uncorrectedIntensityList.Count + ftmsSignalToNoise.Count + ftmsResolution.Count; // Append the maximum reporter ion intensity then the individual reporter ion intensities dataColumns.Add(StringUtilities.DblToString(reporterIntensityMax, 2)); dataColumns.AddRange(reporterIntensityList); // Append the weighted average percent intensity correction if (weightedAvgPctIntensityCorrection < float.Epsilon) { dataColumns.Add("0"); } else { dataColumns.Add(StringUtilities.DblToString(weightedAvgPctIntensityCorrection, 1)); } if (saveObservedMasses) { dataColumns.AddRange(obsMZList); } if (saveUncorrectedIntensities) { dataColumns.AddRange(uncorrectedIntensityList); } if (includeFtmsColumns) { dataColumns.AddRange(ftmsSignalToNoise); dataColumns.AddRange(ftmsResolution); // Uncomment to include the label data m/z value in the _ReporterIons.txt file //if (saveObservedMasses) // dataColumns.AddRange(ftmsLabelDataMz) } writer.WriteLine(string.Join(delimiter.ToString(), dataColumns)); }
public bool ProcessAndStoreSpectrum( clsScanInfo scanInfo, DataInput.clsDataImport dataImportUtilities, clsSpectraCache spectraCache, clsMSSpectrum msSpectrum, clsBaselineNoiseOptions noiseThresholdOptions, bool discardLowIntensityData, bool compressData, double msDataResolution, bool keepRawSpectrum) { var lastKnownLocation = "Start"; try { // Determine the noise threshold intensity for this spectrum // Stored in scanInfo.BaselineNoiseStats lastKnownLocation = "Call ComputeNoiseLevelForMassSpectrum"; ComputeNoiseLevelForMassSpectrum(scanInfo, msSpectrum, noiseThresholdOptions); if (!keepRawSpectrum) { return(true); } // Discard low intensity data, but not for MRM scans if (discardLowIntensityData && scanInfo.MRMScanType == ThermoRawFileReader.MRMScanTypeConstants.NotMRM) { // Discard data below the noise level or below the minimum S/N level // If we are searching for Reporter ions, then it is important to not discard any of the ions in the region of the reporter ion m/z values lastKnownLocation = "Call DiscardDataBelowNoiseThreshold"; dataImportUtilities.DiscardDataBelowNoiseThreshold(msSpectrum, scanInfo.BaselineNoiseStats.NoiseLevel, mReporterIons.MZIntensityFilterIgnoreRangeStart, mReporterIons.MZIntensityFilterIgnoreRangeEnd, noiseThresholdOptions); scanInfo.IonCount = msSpectrum.IonCount; } if (compressData) { lastKnownLocation = "Call CompressSpectraData"; // Again, if we are searching for Reporter ions, then it is important to not discard any of the ions in the region of the reporter ion m/z values CompressSpectraData(msSpectrum, msDataResolution, mReporterIons.MZIntensityFilterIgnoreRangeStart, mReporterIons.MZIntensityFilterIgnoreRangeEnd); } if (msSpectrum.IonCount > MAX_ALLOWABLE_ION_COUNT) { // Do not keep more than 50,000 ions lastKnownLocation = "Call DiscardDataToLimitIonCount"; mSpectraFoundExceedingMaxIonCount += 1; // Display a message at the console the first 10 times we encounter spectra with over MAX_ALLOWABLE_ION_COUNT ions // In addition, display a new message every time a new max value is encountered if (mSpectraFoundExceedingMaxIonCount <= 10 || msSpectrum.IonCount > mMaxIonCountReported) { Console.WriteLine(); Console.WriteLine( "Note: Scan " + scanInfo.ScanNumber + " has " + msSpectrum.IonCount + " ions; " + "will only retain " + MAX_ALLOWABLE_ION_COUNT + " (trimmed " + mSpectraFoundExceedingMaxIonCount.ToString() + " spectra)"); mMaxIonCountReported = msSpectrum.IonCount; } dataImportUtilities.DiscardDataToLimitIonCount(msSpectrum, mReporterIons.MZIntensityFilterIgnoreRangeStart, mReporterIons.MZIntensityFilterIgnoreRangeEnd, MAX_ALLOWABLE_ION_COUNT); scanInfo.IonCount = msSpectrum.IonCount; } lastKnownLocation = "Call AddSpectrumToPool"; var success = spectraCache.AddSpectrumToPool(msSpectrum, scanInfo.ScanNumber); return(success); } catch (Exception ex) { ReportError("Error in ProcessAndStoreSpectrum (LastKnownLocation: " + lastKnownLocation + ")", ex, clsMASIC.eMasicErrorCodes.InputFileDataReadError); return(false); } }