/// <summary>
/// Gets precursor scans directly from the trailer extra. This is intended for DIA files, and by extension only for Ms2 experiments.
/// </summary>
/// <param name="rawFile"></param>
/// <param name="index"></param>
/// <returns></returns>
public static PrecursorScanCollection PrecursorScansByMasterScanMs2Only(IRawDataPlus rawFile, TrailerExtraCollection trailerExtras, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting scan dependents/precursor scans");
PrecursorScanCollection precursorScans = new PrecursorScanCollection();
int ms2Scan = -1;
int ms3Scan = -1;
IEnumerable <int> scans = index.ScanEnumerators[MSOrderType.Ms];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Indexing linked scan events");
// if it is DIA it must be MS2
scans = index.ScanEnumerators[MSOrderType.Ms2];
foreach (int scan in scans)
{
int masterScan = trailerExtras[scan].MasterScan;
precursorScans[scan] = new PrecursorScanData(ms2scan: scan, masterScan: masterScan);
}
progress.Done();
return(precursorScans);
}
public static PrecursorMassCollection PrecursorMasses(IRawDataPlus rawFile, PrecursorScanCollection precursorScans, TrailerExtraCollection trailerExtras, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting precursor masses");
PrecursorMassCollection precursorMasses = new PrecursorMassCollection();
var scans = index.ScanEnumerators[MSOrderType.Any];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Extracting precursor masses");
foreach (int scan in scans)
{
if (index.allScans[scan].MSOrder == MSOrderType.Ms2)
{
double parent_mass = rawFile.GetScanEventForScanNumber(scan).GetReaction(0).PrecursorMass;
precursorMasses[scan] = new PrecursorMassData(trailerExtras[scan].MonoisotopicMZ, parent_mass);
}
if (index.allScans[scan].MSOrder == MSOrderType.Ms3)
{
int ms2scan = precursorScans[scan].MS2Scan;
double parent_mass = rawFile.GetScanEventForScanNumber(scan).GetReaction(0).PrecursorMass;
precursorMasses[scan] = new PrecursorMassData(trailerExtras[ms2scan].MonoisotopicMZ, parent_mass);
}
progress.Update();
}
progress.Done();
return(precursorMasses);
}
DependentsAndPrecursorScansByScanDependents(IRawDataPlus rawFile, ScanIndex index)
{
rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting scan dependents/precursor scans");
PrecursorScanCollection precursorScans = new PrecursorScanCollection();
ScanDependentsCollections dependents = new ScanDependentsCollections();
int ms2Scan = -1;
int ms3Scan = -1;
IEnumerable <int> scans = index.ScanEnumerators[MSOrderType.Ms];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Indexing linked scan events");
foreach (int scan in scans)
{
var scanDependents = rawFile.GetScanDependents(scan, 4);
dependents[scan] = scanDependents;
// check if the ms1 scan has dependent scans
if (scanDependents == null)
{
continue;
}
for (int i = 0; i < scanDependents.ScanDependentDetailArray.Length; i++)
{
if (index.AnalysisOrder == MSOrderType.Ms2) // it is ms2
{
ms2Scan = scanDependents.ScanDependentDetailArray[i].ScanIndex;
precursorScans[ms2Scan] = new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan);
}
else // it is ms3
{
ms2Scan = scanDependents.ScanDependentDetailArray[i].ScanIndex;
var ms2Dependents = rawFile.GetScanDependents(ms2Scan, 4).ScanDependentDetailArray;
if (ms2Dependents.Length != 0) // make sure there is ms3 data
{
ms3Scan = ms2Dependents[0].ScanIndex;
precursorScans[ms2Scan] = new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan);
precursorScans[ms3Scan] = new PrecursorScanData(ms3scan: ms3Scan, ms2Scan: ms2Scan, masterScan: scan);
}
else
{
// there is no ms3 scan, so we only add the ms2 scan
precursorScans[ms2Scan] = new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan);
}
}
}
progress.Update();
}
progress.Done();
return(precursorScans, dependents);
}
public static void ParseDIA(IRawFileThreadManager rawFile, WorkflowParameters parameters)
{
var staticRawFile = rawFile.CreateThreadAccessor();
staticRawFile.SelectInstrument(Device.MS, 1);
staticRawFile.CheckIfBoxcar();
ScanIndex Index = Extract.ScanIndices(rawFile.CreateThreadAccessor());
TrailerExtraCollection trailerExtras = Extract.TrailerExtras(rawFile.CreateThreadAccessor(), Index);
MethodDataContainer methodData = Extract.MethodData(rawFile.CreateThreadAccessor(), Index);
PrecursorScanCollection precursorScans = Extract.PrecursorScansByMasterScanMs2Only(rawFile.CreateThreadAccessor(), trailerExtras, Index);
(CentroidStreamCollection centroidStreams, SegmentScanCollection segmentScans) =
Extract.MsData(rawFile: rawFile.CreateThreadAccessor(), index: Index);
RetentionTimeCollection retentionTimes = Extract.RetentionTimes(rawFile.CreateThreadAccessor(), Index);
ScanMetaDataCollectionDIA metaData = MetaDataProcessingDIA.AggregateMetaDataDIA(centroidStreams, segmentScans, methodData,
trailerExtras, retentionTimes, Index);
RawMetricsDataDIA metrics = null;
if (parameters.ParseParams.Metrics)
{
metrics = MetaDataProcessingDIA.GetMetricsDataDIA(metaData, methodData, staticRawFile.FileName, retentionTimes, Index);
MetricsWriter.WriteMatrix(metrics, staticRawFile.FileName, parameters.ParseParams.OutputDirectory);
}
if (parameters.ParseParams.Parse)
{
string matrixFileName = ReadWrite.GetPathToFile(parameters.ParseParams.OutputDirectory, staticRawFile.FileName, "._parse.txt");
//MatrixWriter.ParseQuantDIA()
//ParseWriter writerDIA = new ParseWriter(matrixFileName, centroidStreams, segmentScans, metaData,
// retentionTimes, trailerExtras, precursorScans, Index);
//writerDIA.WriteMatrixDIA();
}
// I'm not sure what goes into a DIA mgf file, so we aren't making one yet
//if (parameters.ParseParams.WriteMgf)
//{
// ParseWriter writerMGF = new ParseWriter(centroidStreams, segmentScans, parameters, retentionTimes, precursorMasses, precursorScans, trailerExtras, methodData, Index);
// writerMGF.WriteMGF(staticRawFile.FileName);
//}
}
public static void WriteSearchMGF(WorkflowParameters parameters, CentroidStreamCollection centroids, SegmentScanCollection segments, RetentionTimeCollection retentionTimes,
PrecursorMassCollection precursorMasses, PrecursorScanCollection precursorScans, TrailerExtraCollection trailerExtras, MethodDataContainer methodData,
ScanIndex index, string rawFileName, bool fixedScans = false)
{
var pars = parameters.QcParams.SearchParameters;
int[] scans = AdditionalMath.SelectRandomScans(scans: index.ScanEnumerators[MSOrderType.Ms2],
num: parameters.QcParams.NumberSpectra, fixedScans: parameters.QcParams.FixedScans);
string mgfFile = ReadWrite.GetPathToFile(parameters.QcParams.QcSearchDataDirectory, rawFileName, ".mgf");
MgfWriter.WriteMGF(rawFileName, centroids, segments, parameters, retentionTimes, precursorMasses, precursorScans,
trailerExtras, methodData, index, outputFile: mgfFile, scans: scans);
}
public static ScanMetaDataCollectionDDA AggregateMetaDataDDA(CentroidStreamCollection centroidStreams, SegmentScanCollection segmentScans, MethodDataContainer methodData,
PrecursorScanCollection precursorScans, TrailerExtraCollection trailerExtras, PrecursorMassCollection precursorMasses,
RetentionTimeCollection retentionTimes, ScanDependentsCollections scanDependents, ScanEventReactionCollection reactions, ScanIndex index)
{
//ProgressIndicator progress = new ProgressIndicator(index.ScanEnumerators[MSOrderType.Any].Count(),
// "Formatting scan meta data");
ScanMetaDataCollectionDDA metaData = new ScanMetaDataCollectionDDA();
int[] scans = index.ScanEnumerators[MSOrderType.Any];
double isoWindow = MetaDataCalculations.Ms1IsoWindow(methodData);
Console.WriteLine("Calculating meta data");
Console.WriteLine(" MS1 isolation interference");
metaData.Ms1IsolationInterference = MetaDataCalculations.Ms1Interference(centroidStreams, precursorMasses, trailerExtras,
precursorScans, reactions, index);
Console.WriteLine(" MS2 scan cycle density");
metaData.MS2ScansPerCycle = MetaDataCalculations.MS2ScansPerCycle(scanDependents, index);
Console.WriteLine(" Ion injection time");
metaData.FillTime = MetaDataCalculations.FillTimes(trailerExtras, index);
Console.WriteLine(" Duty cycle");
metaData.DutyCycle = MetaDataCalculations.DutyCycle(retentionTimes, index);
Console.WriteLine(" Intensity distribution");
metaData.IntensityDistribution = MetaDataCalculations.IntensityDistributions(centroidStreams, segmentScans, index);
Console.WriteLine(" Summed intensities");
metaData.SummedIntensity = MetaDataCalculations.SummedIntensities(centroidStreams, segmentScans, index);
metaData.FractionConsumingTop80PercentTotalIntensity = MetaDataCalculations.Top80Frac(centroidStreams, segmentScans, index);
//Task.WaitAll();
return(metaData);
}
DependentsAndPrecursorScansByScanDependentsParallel(IRawFileThreadManager rawFileManager, ScanIndex index)
{
//rawFile.SelectInstrument(Device.MS, 1);
Log.Information("Extracting scan dependents/precursor scans");
ConcurrentDictionary <int, PrecursorScanData> precursorScans = new ConcurrentDictionary <int, PrecursorScanData>();
ConcurrentDictionary <int, IScanDependents> dependents = new ConcurrentDictionary <int, IScanDependents>();
//Dictionary<int, PrecursorScanData> precursorScans = new Dictionary<int, PrecursorScanData>();
//Dictionary<int, IScanDependents> dependents = new Dictionary<int, IScanDependents>();
//ConcurrentBag<(int scan, PrecursorScanData data)> precursorBag = new ConcurrentBag<(int scan, PrecursorScanData data)>();
//ConcurrentBag<(int scan, IScanDependents data)> dependentsBag = new ConcurrentBag<(int scan, IScanDependents data)>();
var updateProgressLock = new object();
var addLockTarget = new object();
IEnumerable <int> scans = index.ScanEnumerators[MSOrderType.Ms];
ProgressIndicator progress = new ProgressIndicator(scans.Count(), "Indexing linked scan events");
var batches = scans.Chunk(Constants.MultiThreading.ChunkSize(scans.Count()));
Parallel.ForEach(batches, Constants.MultiThreading.Options(), batch =>
{
int ms2Scan = -1;
int ms3Scan = -1;
IScanDependents scanDependents;
var rawFile = rawFileManager.CreateThreadAccessor();
rawFile.SelectInstrument(Device.MS, 1);
foreach (int scan in batch)
{
scanDependents = rawFile.GetScanDependents(scan, 2);
dependents.AddOrUpdate(scan, scanDependents, (a, b) => b);
// check if the ms1 scan has dependent scans
if (scanDependents == null)
{
return;
}
for (int i = 0; i < scanDependents.ScanDependentDetailArray.Length; i++)
{
if (index.AnalysisOrder == MSOrderType.Ms2) // it is ms2
{
ms2Scan = scanDependents.ScanDependentDetailArray[i].ScanIndex;
//precursorScans.AddOrUpdate(ms2Scan, new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan), (a, b) => b);
precursorScans.TryAdd(ms2Scan, new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan));
}
else // it is ms3
{
ms2Scan = scanDependents.ScanDependentDetailArray[i].ScanIndex;
var ms2Dependents = rawFile.GetScanDependents(ms2Scan, 2).ScanDependentDetailArray;
if (ms2Dependents.Length != 0) // make sure there is ms3 data
{
ms3Scan = ms2Dependents[0].ScanIndex;
precursorScans.AddOrUpdate(ms2Scan, new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan), (a, b) => b);
precursorScans.AddOrUpdate(ms3Scan, new PrecursorScanData(ms3scan: ms3Scan, ms2Scan: ms2Scan, masterScan: scan), (a, b) => b);
}
else
{
// there is no ms3 scan, so we only add the ms2 scan
precursorScans.AddOrUpdate(ms2Scan, new PrecursorScanData(ms2scan: ms2Scan, masterScan: scan), (a, b) => b);
}
}
}
lock (updateProgressLock)
{
progress.Update();
}
}
});
progress.Done();
var outScans = new PrecursorScanCollection();
var outDependents = new ScanDependentsCollections();
foreach (var item in precursorScans)
{
outScans.Add(item.Key, item.Value);
}
foreach (var item in dependents)
{
outDependents.Add(item.Key, item.Value);
}
// check for missing precursor information
/*
* foreach (int scan in index.ScanEnumerators[MSOrderType.Ms2])
* {
* if (outScans.Keys.Contains(scan))
* {
* outScans.HasPrecursorData.Add(scan, true);
* }
* else
* {
* outScans.HasPrecursorData.Add(scan, false);
* }
* }*/
return(outScans, outDependents);
}
public static RawMetricsDataDDA GetMetricsDataDDA(ScanMetaDataCollectionDDA metaData, MethodDataContainer methodData,
string rawFileName, RetentionTimeCollection retentionTimes, ScanIndex index, PrecursorPeakCollection peakData,
PrecursorScanCollection precursorScans, QuantDataCollection quantData = null)
{
RawMetricsDataDDA metricsData = new RawMetricsDataDDA();
metricsData.DateAcquired = methodData.CreationDate;
metricsData.Instrument = methodData.Instrument;
Console.WriteLine("Calculating metrics");
metricsData.RawFileName = rawFileName;
metricsData.Instrument = methodData.Instrument;
metricsData.MS1Analyzer = methodData.MassAnalyzers[MSOrderType.Ms];
metricsData.MS2Analyzer = methodData.MassAnalyzers[MSOrderType.Ms2];
metricsData.TotalAnalysisTime = retentionTimes[index.ScanEnumerators[MSOrderType.Any].Last()] -
retentionTimes[index.ScanEnumerators[MSOrderType.Any].First()];
metricsData.NumberOfEsiFlags = MetricsCalculations.NumberOfEsiFlags(metaData, index);
metricsData.TotalScans = index.TotalScans;
metricsData.MS1Scans = index.ScanEnumerators[MSOrderType.Ms].Length;
metricsData.MS2Scans = index.ScanEnumerators[MSOrderType.Ms2].Length;
if (methodData.AnalysisOrder == MSOrderType.Ms3)
{
metricsData.MS3Analyzer = methodData.MassAnalyzers[MSOrderType.Ms3];
metricsData.MS3Scans = index.ScanEnumerators[MSOrderType.Ms3].Length;
}
else
{
metricsData.MS3Analyzer = MassAnalyzerType.Any;
metricsData.MS3Scans = 0;
}
var pickedMs1 = new HashSet <int>((from x in index.ScanEnumerators[methodData.AnalysisOrder]
select precursorScans[x].MasterScan)).ToList();
metricsData.MSOrder = methodData.AnalysisOrder;
metricsData.MedianSummedMS1Intensity = MetricsCalculations.GetMedianSummedMSIntensity(metaData.SummedIntensity, index, MSOrderType.Ms);
metricsData.MedianSummedMS2Intensity = MetricsCalculations.GetMedianSummedMSIntensity(metaData.SummedIntensity, index, MSOrderType.Ms2);
metricsData.MedianPrecursorIntensity = (from x in peakData.Keys select peakData[x].ParentIntensity).ToArray().Percentile(50);
metricsData.MedianMS1FillTime = MetricsCalculations.GetMedianMSFillTime(metaData.FillTime, index, MSOrderType.Ms);
metricsData.MedianMS2FillTime = MetricsCalculations.GetMedianMSFillTime(metaData.FillTime, index, MSOrderType.Ms2);
if (methodData.AnalysisOrder == MSOrderType.Ms3)
{
metricsData.MedianMS3FillTime = MetricsCalculations.GetMedianMSFillTime(metaData.FillTime, index, MSOrderType.Ms3);
}
metricsData.MeanTopN = MetricsCalculations.GetMeanMs2ScansPerCycle(metaData.MS2ScansPerCycle);
metricsData.MeanDutyCycle = MetricsCalculations.GetMedianDutyCycle(metaData.DutyCycle, index);
metricsData.MedianMs2FractionConsumingTop80PercentTotalIntensity =
MetricsCalculations.GetMedianMs2FractionConsumingTop80PercentTotalIntensity(
metaData.FractionConsumingTop80PercentTotalIntensity, index);
metricsData.MS1ScanRate = metricsData.MS1Scans / metricsData.TotalAnalysisTime;
metricsData.MS2ScanRate = metricsData.MS2Scans / metricsData.TotalAnalysisTime;
if (methodData.AnalysisOrder == MSOrderType.Ms3)
{
metricsData.MS3ScanRate = metricsData.MS3Scans / metricsData.TotalAnalysisTime;
}
metricsData.MedianBaselinePeakWidth = peakData.PeakShapeMedians.Width.P10;
metricsData.MedianHalfHeightPeakWidth = peakData.PeakShapeMedians.Width.P50;
// we can't access the instrument method in Linux, so we will assume the gradient length is the length of the MS acquisition
metricsData.Gradient = retentionTimes[index.allScans.Keys.Max()];
metricsData.PeakCapacity = metricsData.Gradient / metricsData.MedianHalfHeightPeakWidth;
metricsData.MedianAsymmetryFactor = peakData.PeakShapeMedians.Asymmetry.P10;
// add isolation interference
metricsData.MedianMs1IsolationInterference = (from scan in index.ScanEnumerators[methodData.AnalysisOrder]
select metaData.Ms1IsolationInterference[scan]).ToArray().Percentile(50);
(double timeBefore, double timeAfter, double fracAbove) = MetricsCalculations.ChromIntensityMetrics(metaData, retentionTimes, index);
metricsData.TimeBeforeFirstScanToExceedPoint1MaxIntensity = timeBefore;
metricsData.TimeAfterLastScanToExceedPoint1MaxIntensity = timeAfter;
metricsData.FractionOfRunAbovePoint1MaxIntensity = fracAbove;
metricsData.Ms1FillTimeDistribution = new Distribution((from x in index.ScanEnumerators[MSOrderType.Ms] select metaData.FillTime[x]).ToArray());
metricsData.Ms2FillTimeDistribution = new Distribution((from x in index.ScanEnumerators[MSOrderType.Ms2] select metaData.FillTime[x]).ToArray());
if (methodData.AnalysisOrder == MSOrderType.Ms3)
{
metricsData.Ms3FillTimeDistribution = new Distribution((from x in index.ScanEnumerators[MSOrderType.Ms3] select metaData.FillTime[x]).ToArray());
}
metricsData.PeakShape.Asymmetry.P10 = peakData.PeakShapeMedians.Asymmetry.P10;
metricsData.PeakShape.Asymmetry.P50 = peakData.PeakShapeMedians.Asymmetry.P50;
metricsData.PeakShape.Width.P10 = peakData.PeakShapeMedians.Width.P10;
metricsData.PeakShape.Width.P50 = peakData.PeakShapeMedians.Width.P50;
// now add the quant meta data, if quant was performed
double medianReporterIntensity = 0;
QuantMetaData quantMetaData = new QuantMetaData();
SerializableDictionary <string, double> medianReporterIntensityByChannel = new SerializableDictionary <string, double>();
if (quantData != null)
{
string reagent = quantData.LabelingReagents;
string[] allTags = new LabelingReagents().Reagents[reagent].Labels;
List <double> allChannels = new List <double>();
Dictionary <string, List <double> > byChannel = new Dictionary <string, List <double> >();
foreach (string tag in allTags)
{
byChannel.Add(tag, new List <double>());
}
foreach (int scan in index.ScanEnumerators[methodData.AnalysisOrder])
{
foreach (string tag in allTags)
{
byChannel[tag].Add(quantData[scan][tag].Intensity);
allChannels.Add(quantData[scan][tag].Intensity);
}
}
medianReporterIntensity = allChannels.ToArray().Percentile(50);
foreach (string tag in allTags)
{
medianReporterIntensityByChannel[tag] = byChannel[tag].ToArray().Percentile(50);
}
quantMetaData.medianReporterIntensity = medianReporterIntensity;
quantMetaData.medianReporterIntensityByChannel = medianReporterIntensityByChannel;
quantMetaData.quantTags = allTags;
metricsData.QuantMeta = quantMetaData;
metricsData.IncludesQuant = true;
}
return(metricsData);
}
public static Dictionary <int, double> Ms1Interference(CentroidStreamCollection centroidStreams, PrecursorMassCollection precursorMasses,
TrailerExtraCollection trailerExtras, PrecursorScanCollection precursorScans, ScanEventReactionCollection reactions, ScanIndex index)
{
ConcurrentDictionary <int, double> interference = new ConcurrentDictionary <int, double>();
int chunkSize = Constants.MultiThreading.ChunkSize(index.ScanEnumerators[index.AnalysisOrder].Count());
var batches = index.ScanEnumerators[index.AnalysisOrder].Chunk(chunkSize);
Parallel.ForEach(batches, Constants.MultiThreading.Options(), batch =>
{
foreach (int scan in batch)
{
int preScan = precursorScans[scan].MasterScan;
interference.AddOrUpdate(scan, Algorithms.Ms1Interference.CalculateForOneScan(centroidStreams[preScan], reactions[scan],
precursorMasses[scan].MonoisotopicMZ, trailerExtras[scan].ChargeState), (a, b) => b);
}
});
var interferenceOut = new Dictionary <int, double>();
foreach (var item in interference)
{
interferenceOut.Add(item.Key, item.Value);
}
return(interferenceOut);
}
public static PrecursorPeakCollection AnalyzeAllPeaks(CentroidStreamCollection centroids, RetentionTimeCollection retentionTimes,
PrecursorMassCollection precursorMasses, PrecursorScanCollection precursorScans, ScanIndex index, int MaxProcesses)
{
ConcurrentDictionary <int, PrecursorPeakData> peaks = new ConcurrentDictionary <int, PrecursorPeakData>();
DistributionMultiple allPeaksAsymmetry = new DistributionMultiple();
DistributionMultiple allPeaksWidths = new DistributionMultiple();
var lockTarget = new object(); // this is so we can keep track of progress in the parallel loop
int chunkSize = Constants.MultiThreading.ChunkSize(index.ScanEnumerators[MSOrderType.Ms2].Count());
var batches = index.ScanEnumerators[MSOrderType.Ms2].Chunk(chunkSize);
ProgressIndicator P = new ProgressIndicator(total: index.ScanEnumerators[MSOrderType.Ms2].Length, message: "Analyzing precursor peaks");
P.Start();
Parallel.ForEach(batches, Constants.MultiThreading.Options(MaxProcesses), batch =>
{
PrecursorPeakData peak;
foreach (int scan in batch)
{
// [2018-12-04] changing to use picked mass and not monoisomass. The monoisomass might be low in intensity and would not represent the whole elution profile
peak = OnePeak(centroids, retentionTimes, precursorMasses[scan].ParentMZ, precursorScans[scan].MasterScan, ddScan: scan, index: index);
if (peak.NScans < 5 | peak.PeakFound == false |
peak.ContainsFirstMS1Scan | peak.ContainsLastMS1Scan)
{
peak.PeakShape = null;
}
else
{
var newShape = GetPeakShape(peak);
peak.PeakShape = newShape;
allPeaksAsymmetry.Add(newShape.Asymmetry);
allPeaksWidths.Add(newShape.Width);
}
peak.Area = CalculatePeakArea(peak);
peaks.AddOrUpdate(scan, peak, (a, b) => b);
lock (lockTarget)
{
P.Update();
}
}
});
P.Done();
var peaksOut = new PrecursorPeakCollection();
foreach (var item in peaks)
{
peaksOut.Add(item.Key, item.Value);
}
if (allPeaksWidths.P50.Count() == 0)
{
peaksOut.PeakShapeMedians = new Data.Containers.PeakShape(width: new Width(), asymmetry: new Asymmetry(), peakMax: 0);
}
else
{
peaksOut.PeakShapeMedians = new Data.Containers.PeakShape(width: allPeaksWidths.GetMedians(), asymmetry: allPeaksAsymmetry.GetMedians(), peakMax: 0);
}
return(peaksOut);
}
public static void RefineMonoIsoMassChargeValues(WorkFlows.WorkflowParameters parameters, CentroidStreamCollection centroids, PrecursorMassCollection precursorMasses, TrailerExtraCollection trailerExtras, PrecursorPeakCollection precursorPeaks, PrecursorScanCollection precursorScans)
{
int ms2Scan, ms1Scan, refinedCharge;
double refinedMass;
ProgressIndicator P = new ProgressIndicator(precursorPeaks.Count(), "Refining precursor charge and monoisotopic mass");
P.Start();
foreach (var peak in precursorPeaks)
{
ms2Scan = peak.Value.Ms2Scan;
if (peak.Value.PeakFound)
{
ms1Scan = peak.Value.MaxScan;
}
else
{
ms1Scan = precursorScans[ms2Scan].MasterScan;
}
(refinedCharge, refinedMass) = GetMonoIsotopicMassCharge(centroids[ms1Scan], precursorMasses[ms2Scan].ParentMZ,
trailerExtras[ms2Scan].ChargeState, parameters.ConsideredChargeStates.Min, parameters.ConsideredChargeStates.Max);
precursorMasses[ms2Scan].MonoisotopicMZ = refinedMass;
trailerExtras[ms2Scan].MonoisotopicMZ = refinedMass;
trailerExtras[ms2Scan].ChargeState = refinedCharge;
P.Update();
}
P.Done();
}
