/// <summary>
/// Constructor
/// </summary>
/// <param name="reporterIons"></param>
/// <param name="peakFinder"></param>
public clsScanTracking(clsReporterIons reporterIons, clsMASICPeakFinder peakFinder)
{
mReporterIons = reporterIons;
mPeakFinder = peakFinder;
ScanStats = new List <ScanStatsEntry>();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="masicOptions"></param>
/// <param name="peakFinder"></param>
/// <param name="parentIonProcessor"></param>
/// <param name="scanTracking"></param>
public clsDataImportThermoRaw(
clsMASICOptions masicOptions,
clsMASICPeakFinder peakFinder,
clsParentIonProcessing parentIonProcessor,
clsScanTracking scanTracking)
: base(masicOptions, peakFinder, parentIonProcessor, scanTracking)
{
}
public bool ProcessMRMList(
clsScanList scanList,
clsSpectraCache spectraCache,
clsSICProcessing sicProcessor,
clsXMLResultsWriter xmlResultsWriter,
clsMASICPeakFinder peakFinder,
ref int parentIonsProcessed)
{
try
{
// Initialize sicDetails
var sicDetails = new clsSICDetails();
sicDetails.Reset();
sicDetails.SICScanType = clsScanList.eScanTypeConstants.FragScan;
for (var parentIonIndex = 0; parentIonIndex < scanList.ParentIons.Count; parentIonIndex++)
{
if (scanList.ParentIons[parentIonIndex].MRMDaughterMZ <= 0)
{
continue;
}
// Step 1: Create the SIC for this MRM Parent/Daughter pair
var parentIonMZ = scanList.ParentIons[parentIonIndex].MZ;
var mrmDaughterMZ = scanList.ParentIons[parentIonIndex].MRMDaughterMZ;
var searchToleranceHalfWidth = scanList.ParentIons[parentIonIndex].MRMToleranceHalfWidth;
// Reset SICData
sicDetails.SICData.Clear();
// Step through the fragmentation spectra, finding those that have matching parent and daughter ion m/z values
for (var scanIndex = 0; scanIndex < scanList.FragScans.Count; scanIndex++)
{
if (scanList.FragScans[scanIndex].MRMScanType != MRMScanTypeConstants.SRM)
{
continue;
}
var fragScan = scanList.FragScans[scanIndex];
var useScan = false;
for (var mrmMassIndex = 0; mrmMassIndex < fragScan.MRMScanInfo.MRMMassCount; mrmMassIndex++)
{
if (MRMParentDaughterMatch(fragScan.MRMScanInfo.ParentIonMZ,
fragScan.MRMScanInfo.MRMMassList[mrmMassIndex].CentralMass,
parentIonMZ, mrmDaughterMZ))
{
useScan = true;
break;
}
}
if (!useScan)
{
continue;
}
// Include this scan in the SIC for this parent ion
mDataAggregation.FindMaxValueInMZRange(spectraCache,
scanList.FragScans[scanIndex],
mrmDaughterMZ - searchToleranceHalfWidth,
mrmDaughterMZ + searchToleranceHalfWidth,
out var closestMZ, out var matchIntensity);
sicDetails.AddData(fragScan.ScanNumber, matchIntensity, closestMZ, scanIndex);
}
// Step 2: Find the largest peak in the SIC
// Compute the noise level; the noise level may change with increasing index number if the background is increasing for a given m/z
var success = peakFinder.ComputeDualTrimmedNoiseLevelTTest(sicDetails.SICIntensities, 0,
sicDetails.SICDataCount - 1,
mOptions.SICOptions.SICPeakFinderOptions.
SICBaselineNoiseOptions,
out var noiseStatsSegments);
if (!success)
{
SetLocalErrorCode(clsMASIC.eMasicErrorCodes.FindSICPeaksError, true);
return(false);
}
// Initialize the peak
scanList.ParentIons[parentIonIndex].SICStats.Peak = new clsSICStatsPeak();
// Find the data point with the maximum intensity
double maximumIntensity = 0;
scanList.ParentIons[parentIonIndex].SICStats.Peak.IndexObserved = 0;
for (var scanIndex = 0; scanIndex < sicDetails.SICDataCount; scanIndex++)
{
var intensity = sicDetails.SICIntensities[scanIndex];
if (intensity > maximumIntensity)
{
maximumIntensity = intensity;
scanList.ParentIons[parentIonIndex].SICStats.Peak.IndexObserved = scanIndex;
}
}
// Compute the minimum potential peak area in the entire SIC, populating udtSICPotentialAreaStatsInFullSIC
peakFinder.FindPotentialPeakArea(sicDetails.SICData,
out var potentialAreaStatsInFullSIC,
mOptions.SICOptions.SICPeakFinderOptions);
// Update .BaselineNoiseStats in scanList.ParentIons(parentIonIndex).SICStats.Peak
scanList.ParentIons[parentIonIndex].SICStats.Peak.BaselineNoiseStats = peakFinder.LookupNoiseStatsUsingSegments(
scanList.ParentIons[parentIonIndex].SICStats.Peak.IndexObserved,
noiseStatsSegments);
var parentIon = scanList.ParentIons[parentIonIndex];
// Clear udtSICPotentialAreaStatsForPeak
parentIon.SICStats.SICPotentialAreaStatsForPeak = new clsSICPotentialAreaStats();
var peakIsValid = peakFinder.FindSICPeakAndArea(sicDetails.SICData,
out var potentialAreaStatsForPeakOut,
parentIon.SICStats.Peak, out var smoothedYDataSubset,
mOptions.SICOptions.SICPeakFinderOptions,
potentialAreaStatsInFullSIC, false,
scanList.SIMDataPresent, false);
parentIon.SICStats.SICPotentialAreaStatsForPeak = potentialAreaStatsForPeakOut;
sicProcessor.StorePeakInParentIon(scanList, parentIonIndex, sicDetails,
parentIon.SICStats.SICPotentialAreaStatsForPeak,
parentIon.SICStats.Peak, peakIsValid);
// Step 3: store the results
// Possibly save the stats for this SIC to the SICData file
mDataOutputHandler.SaveSICDataToText(mOptions.SICOptions, scanList, parentIonIndex, sicDetails);
// Save the stats for this SIC to the XML file
xmlResultsWriter.SaveDataToXML(scanList, parentIonIndex, sicDetails, smoothedYDataSubset,
mDataOutputHandler);
parentIonsProcessed += 1;
// ---------------------------------------------------------
// Update progress
// ---------------------------------------------------------
try
{
if (scanList.ParentIons.Count > 1)
{
UpdateProgress((short)(parentIonsProcessed / (double)(scanList.ParentIons.Count - 1) * 100));
}
else
{
UpdateProgress(0);
}
UpdateCacheStats(spectraCache);
if (mOptions.AbortProcessing)
{
scanList.ProcessingIncomplete = true;
break;
}
if (parentIonsProcessed % 100 == 0)
{
if (DateTime.UtcNow.Subtract(mOptions.LastParentIonProcessingLogTime).TotalSeconds >= 10 || parentIonsProcessed % 500 == 0)
{
ReportMessage("Parent Ions Processed: " + parentIonsProcessed.ToString());
Console.Write(".");
mOptions.LastParentIonProcessingLogTime = DateTime.UtcNow;
}
}
}
catch (Exception ex)
{
ReportError("Error updating progress", ex, clsMASIC.eMasicErrorCodes.CreateSICsError);
}
}
return(true);
}
catch (Exception ex)
{
ReportError("Error creating SICs for MRM spectra", ex, clsMASIC.eMasicErrorCodes.CreateSICsError);
return(false);
}
}
public void Setup()
{
mMASICPeakFinder = new clsMASICPeakFinder();
}
