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