Esempio n. 1
0
        public static void Quantify(this QuantDataCollection quantData, RawDataCollection rawData, IRawDataPlus rawFile, string labelingReagent)
        {
            MassAnalyzerType quantAnalyzer = rawData.methodData.QuantAnalyzer;

            if (quantAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
            {
                rawData.ExtractCentroidStreams(rawFile, rawData.methodData.AnalysisOrder);
            }
            else
            {
                rawData.ExtractSegmentScans(rawFile, rawData.methodData.AnalysisOrder);
            }

            int[] scans;

            ScanIndex scanIndex = rawData.scanIndex;
            Dictionary <int, CentroidStreamData> centroidScans = rawData.centroidStreams;
            Dictionary <int, SegmentedScanData>  segmentScans  = rawData.segmentedScans;

            scans = scanIndex.ScanEnumerators[scanIndex.AnalysisOrder];

            ProgressIndicator progress = new ProgressIndicator(scans.Length, "Quantifying reporter ions");

            quantData.LabelingReagents = labelingReagent;

            foreach (int scan in scans)
            {
                if (quantAnalyzer == MassAnalyzerType.MassAnalyzerFTMS)
                {
                    quantData.Add(scan, new QuantifyReporters(centroidScans[scan], labelingReagent).quantData);
                }
                else
                {
                    quantData.Add(scan, new QuantifyReporters(segmentScans[scan], labelingReagent).quantData);
                }

                progress.Update();
            }
            progress.Done();
            rawData.Performed.Add(Operations.Quantification);
        }
Esempio n. 2
0
        public static void Check(this RawDataCollection rawData, IRawDataPlus rawFile, List <Operations> operations)
        {
            if (operations.Contains(Operations.MethodData))
            {
                if (!rawData.Performed.Contains(Operations.MethodData))
                {
                    rawData.ExtractMethodData(rawFile);
                }
            }

            if (operations.Contains(Operations.PrecursorMasses))
            {
                if (!rawData.Performed.Contains(Operations.PrecursorMasses))
                {
                    rawData.ExtractPrecursorMasses(rawFile);
                }
            }

            if (operations.Contains(Operations.PrecursorScans))
            {
                if (!rawData.Performed.Contains(Operations.PrecursorScans))
                {
                    rawData.ExtractPrecursorScans(rawFile);
                }
            }

            if (operations.Contains(Operations.RetentionTimes))
            {
                if (!rawData.Performed.Contains(Operations.RetentionTimes))
                {
                    rawData.ExtractRetentionTimes(rawFile);
                }
            }

            if (operations.Contains(Operations.ScanIndex))
            {
                if (!rawData.Performed.Contains(Operations.ScanIndex))
                {
                    rawData.ExtractScanIndex(rawFile);
                }
            }

            if (operations.Contains(Operations.TrailerExtras))
            {
                if (!rawData.Performed.Contains(Operations.TrailerExtras))
                {
                    rawData.ExtractTrailerExtra(rawFile);
                }
            }

            if (operations.Contains(Operations.Ms1CentroidStreams))
            {
                if (!rawData.Performed.Contains(Operations.Ms1CentroidStreams))
                {
                    rawData.ExtractCentroidStreams(rawFile, MSOrder: MSOrderType.Ms);
                }
            }

            if (operations.Contains(Operations.Ms2CentroidStreams))
            {
                if (!rawData.Performed.Contains(Operations.Ms2CentroidStreams))
                {
                    rawData.ExtractCentroidStreams(rawFile, MSOrder: MSOrderType.Ms2);
                }
            }

            if (operations.Contains(Operations.Ms3CentroidStreams))
            {
                if (!rawData.Performed.Contains(Operations.Ms3CentroidStreams))
                {
                    rawData.ExtractCentroidStreams(rawFile, MSOrder: MSOrderType.Ms3);
                }
            }

            if (operations.Contains(Operations.Ms1SegmentedScans))
            {
                if (!rawData.Performed.Contains(Operations.Ms1SegmentedScans))
                {
                    rawData.ExtractSegmentScans(rawFile, MSOrder: MSOrderType.Ms);
                }
            }

            if (operations.Contains(Operations.Ms2SegmentedScans))
            {
                if (!rawData.Performed.Contains(Operations.Ms2SegmentedScans))
                {
                    rawData.ExtractSegmentScans(rawFile, MSOrder: MSOrderType.Ms2);
                }
            }

            if (operations.Contains(Operations.Ms3SegmentedScans))
            {
                if (!rawData.Performed.Contains(Operations.Ms3SegmentedScans))
                {
                    rawData.ExtractSegmentScans(rawFile, MSOrder: MSOrderType.Ms3);
                }
            }

            if (operations.Contains(Operations.MetaData))
            {
                if (!rawData.Performed.Contains(Operations.MetaData))
                {
                    rawData.metaData.AggregateMetaData(rawData, rawFile);
                }
            }

            if (operations.Contains(Operations.PeakRetAndInt))
            {
                if (!rawData.Performed.Contains(Operations.PeakRetAndInt))
                {
                    AnalyzePeaks.CalcPeakRetTimesAndInts(rawData, rawFile);
                }
            }

            if (operations.Contains(Operations.PeakShape))
            {
                if (!rawData.Performed.Contains(Operations.PeakShape))
                {
                    AnalyzePeaks.CalculatePeakShapes(rawData, rawFile);
                }
            }

            if (operations.Contains(Operations.PeakArea))
            {
                if (!rawData.Performed.Contains(Operations.PeakArea))
                {
                    AnalyzePeaks.QuantifyPrecursorPeaks(rawData, rawFile);
                }
            }
        }