public bool TrySetReplicateChecked(ChromatogramSet chromatogramSet, bool isChecked)
 {
     for (int index = 0; index < checkedListBoxResults.Items.Count; index ++)
     {
         ListBoxItem item = (ListBoxItem) checkedListBoxResults.Items[index];
         if (ReferenceEquals(chromatogramSet, item.ChromatogramSet))
         {
             checkedListBoxResults.SetItemChecked(index, isChecked);
             return true;
         }
     }
     return false;
 }
Esempio n. 2
0
        private void DisplayTransitions(IRegressionFunction timeRegressionFunction,
            TransitionDocNode nodeTranSelected,
            ChromatogramSet chromatograms,
            float mzMatchTolerance,
            TransitionGroupDocNode nodeGroup,
            ChromatogramGroupInfo chromGroupInfo,
            PaneKey graphPaneKey,
            DisplayTypeChrom displayType,
            ref double bestStartTime,
            ref double bestEndTime)
        {
            var fileId = chromatograms.FindFile(chromGroupInfo);

            // Get points for all transitions, and pick maximum peaks.
            ChromatogramInfo[] arrayChromInfo;
            var displayTrans = GetDisplayTransitions(nodeGroup, displayType).ToArray();
            int numTrans = displayTrans.Length;
            int numSteps = 0;
            bool allowEmpty = false;

            if (IsSingleTransitionDisplay && nodeTranSelected != null)
            {
                if (!displayTrans.Contains(nodeTranSelected))
                {
                    arrayChromInfo = new ChromatogramInfo[0];
                    displayTrans = new TransitionDocNode[0];
                    numTrans = 0;
                }
                else
                {
                    arrayChromInfo = chromGroupInfo.GetAllTransitionInfo((float) nodeTranSelected.Mz,
                                                                            mzMatchTolerance,
                                                                            chromatograms.OptimizationFunction);

                    if (chromatograms.OptimizationFunction != null)
                    {
                        // Make sure the number of steps matches what will show up in the summary
                        // graphs, or the colors won't match up.
                        int numStepsExpected = chromatograms.OptimizationFunction.StepCount*2 + 1;
                        if (arrayChromInfo.Length != numStepsExpected)
                        {
                            arrayChromInfo = ResizeArrayChromInfo(arrayChromInfo, numStepsExpected);
                            allowEmpty = true;
                        }
                    }

                    numTrans = arrayChromInfo.Length;
                    displayTrans = new TransitionDocNode[numTrans];
                    for (int i = 0; i < numTrans; i++)
                        displayTrans[i] = nodeTranSelected;
                }
                numSteps = numTrans/2;
            }
            else
            {
                arrayChromInfo = new ChromatogramInfo[numTrans];
                for (int i = 0; i < numTrans; i++)
                {
                    var nodeTran = displayTrans[i];
                    // Get chromatogram info for this transition
                    arrayChromInfo[i] = chromGroupInfo.GetTransitionInfo((float) nodeTran.Mz, mzMatchTolerance);
                }
            }

            int bestPeakTran = -1;
            TransitionChromInfo tranPeakInfo = null;
            float maxPeakHeight = float.MinValue;
            int numPeaks = chromGroupInfo.NumPeaks;
            var maxPeakTrans = new int[numPeaks];
            var maxPeakHeights = new float[numPeaks];
            for (int i = 0; i < numPeaks; i++)
                maxPeakHeights[i] = float.MinValue;
            var transform = Transform;
            // Prepare arrays of values for library dot-product
            double[] expectedIntensities = null;
            double[][] peakAreas = null;
            bool isShowingMs = displayTrans.Any(nodeTran => nodeTran.IsMs1);
            bool isShowingMsMs = displayTrans.Any(nodeTran => !nodeTran.IsMs1);
            bool isFullScanMs = DocumentUI.Settings.TransitionSettings.FullScan.IsEnabledMs && isShowingMs;
            if ((isFullScanMs && !isShowingMsMs && nodeGroup.HasIsotopeDist) ||
                (!isFullScanMs && nodeGroup.HasLibInfo))
            {
                expectedIntensities = new double[numTrans];
                peakAreas = new double[numPeaks][];
                for (int i = 0; i < numPeaks; i++)
                    peakAreas[i] = new double[numTrans];
            }

            // Find the transition with the maximum peak height for the best peak
            for (int i = 0; i < numTrans; i++)
            {
                var nodeTran = displayTrans[i];
                int step = (numSteps > 0 ? i - numSteps : 0);
                var transitionChromInfo = GetTransitionChromInfo(nodeTran, _chromIndex, fileId, step);
                if (transitionChromInfo == null)
                    continue;

                if (maxPeakHeight < transitionChromInfo.Height)
                {
                    maxPeakHeight = transitionChromInfo.Height;
                    bestPeakTran = i;
                    tranPeakInfo = transitionChromInfo;
                }
                AddBestPeakTimes(transitionChromInfo, ref bestStartTime, ref bestEndTime);
            }

            for (int i = 0; i < numTrans; i++)
            {
                var nodeTran = displayTrans[i];

                // Store library intensities for dot-product
                if (expectedIntensities != null)
                {
                    if (isFullScanMs)
                        expectedIntensities[i] = nodeTran.HasDistInfo ? nodeTran.IsotopeDistInfo.Proportion : 0;
                    else
                        expectedIntensities[i] = nodeTran.HasLibInfo ? nodeTran.LibInfo.Intensity : 0;
                }

                var info = arrayChromInfo[i];
                if (info == null)
                    continue;

                // Apply any active transform
                info.Transform(transform);

                for (int j = 0; j < numPeaks; j++)
                {
                    var peak = info.GetPeak(j);

                    // Exclude any peaks between the boundaries of the chosen peak.
                    if (IntersectPeaks(peak, tranPeakInfo))
                        continue;

                    // Store peak intensity for dot-product
                    if (peakAreas != null)
                        peakAreas[j][i] = peak.Area;

                    // Keep track of which transition has the max height for each peak
                    if (maxPeakHeights[j] < peak.Height)
                    {
                        maxPeakHeights[j] = peak.Height;
                        maxPeakTrans[j] = i;
                    }
                }
            }

            // Calculate library dot-products, if possible
            double[] dotProducts = null;
            double bestProduct = 0;
            int minProductTrans = isFullScanMs
                                        ? TransitionGroupDocNode.MIN_DOT_PRODUCT_MS1_TRANSITIONS
                                        : TransitionGroupDocNode.MIN_DOT_PRODUCT_TRANSITIONS;
            if (peakAreas != null && numTrans >= minProductTrans)
            {
                var tranGroupChromInfo = GetTransitionGroupChromInfo(nodeGroup, fileId, _chromIndex);
                double? dotProduct = null;
                if (tranGroupChromInfo != null)
                {
                    dotProduct = isFullScanMs
                                        ? tranGroupChromInfo.IsotopeDotProduct
                                        : tranGroupChromInfo.LibraryDotProduct;
                }
                if (dotProduct.HasValue)
                {
                    bestProduct = dotProduct.Value;

                    var statExpectedIntensities = new Statistics(expectedIntensities);
                    for (int i = 0; i < peakAreas.Length; i++)
                    {
                        var statPeakAreas = new Statistics(peakAreas[i]);
                        double dotProductCurrent = statPeakAreas.NormalizedContrastAngleSqrt(statExpectedIntensities);
                        // Only show products that are greater than the best peak product,
                        // and by enough to be a significant improvement.  Also the library product
                        // on the group node is stored as a float, which means the version
                        // hear calculated as a double can be larger, but really represent
                        // the same number.
                        if (dotProductCurrent > bestProduct &&
                            dotProductCurrent > 0.5 &&
                            dotProductCurrent - bestProduct > 0.05)
                        {
                            if (dotProducts == null)
                                dotProducts = new double[numPeaks];
                            dotProducts[i] = dotProductCurrent;
                        }
                    }
                }
            }

            // Create graph items
            int iColor = 0;
            int lineWidth = LineWidth;
            float fontSize = FontSize;
            // We want the product ion colors to stay the same whether they are displayed:
            // 1. In a single pane with the precursor ions (Transitions -> All)
            // 2. In a separate pane of the split graph (Transitions -> All AND Transitions -> Split Graph)
            // 3. In a single pane by themselves (Transition -> Products)
            // We will use an offset in the colors array for cases 2 and 3 so that we do not reuse the precursor ion colors.
            var nodeDisplayType = GetDisplayType(DocumentUI, nodeGroup);
            int colorOffset = 0;
            if(displayType == DisplayTypeChrom.products &&
                (nodeDisplayType != DisplayTypeChrom.single ||
                (nodeDisplayType == DisplayTypeChrom.single && chromatograms.OptimizationFunction == null)))
            {
                colorOffset = GetDisplayTransitions(nodeGroup, DisplayTypeChrom.precursors).Count();
            }

            for (int i = 0; i < numTrans; i++)
            {
                var info = arrayChromInfo[i];
                if (info == null && !allowEmpty)
                    continue;

                var nodeTran = displayTrans[i];
                int step = numSteps != 0 ? i - numSteps : 0;

                Color color;
                bool shade = false;
                int width = lineWidth;
                if ((numSteps == 0 && ReferenceEquals(nodeTran, nodeTranSelected) ||
                     (numSteps > 0 && step == 0)))
                {
                    color = ChromGraphItem.ColorSelected;
                    shade = true;
                    width++;
                }
                else
                {
                    color = COLORS_LIBRARY[(iColor + colorOffset) % COLORS_LIBRARY.Length];
                }

                TransitionChromInfo tranPeakInfoGraph = null;
                if (bestPeakTran == i)
                    tranPeakInfoGraph = tranPeakInfo;

                var scanName = nodeTran.FragmentIonName;
                if (nodeTran.Transition.Charge != 1)  // Positive singly charged is uninteresting
                    scanName += Transition.GetChargeIndicator(nodeTran.Transition.Charge);
                if (nodeTran.Transition.MassIndex != 0)
                    scanName += Environment.NewLine + Transition.GetMassIndexText(nodeTran.Transition.MassIndex);
                var fullScanInfo = new FullScanInfo
                {
                    ChromInfo = info,
                    ScanName = scanName
                };
                if (fullScanInfo.ChromInfo != null && fullScanInfo.ChromInfo.ExtractionWidth > 0)
                    _enableTrackingDot = true;
                var graphItem = new ChromGraphItem(nodeGroup,
                    nodeTran,
                    info,
                    tranPeakInfoGraph,
                    timeRegressionFunction,
                    GetAnnotationFlags(i, maxPeakTrans, maxPeakHeights),
                    dotProducts,
                    bestProduct,
                    isFullScanMs,
                    false,
                    step,
                    color,
                    fontSize,
                    width,
                    fullScanInfo);
                _graphHelper.AddChromatogram(graphPaneKey, graphItem);
                if (shade)
                {
                    ShadeGraph(tranPeakInfo,info,timeRegressionFunction,dotProducts,bestProduct,isFullScanMs,step,fontSize,width,fullScanInfo,graphPaneKey);
                }
                iColor++;
            }

            var graphPane = _graphHelper.GetGraphPane(graphPaneKey);
            if (graphPane == null)
                _enableTrackingDot = false;
            if (_enableTrackingDot)
            {
                graphPane.CurveList.Insert(FULLSCAN_TRACKING_INDEX, CreateScanPoint(Color.Black));
                graphPane.CurveList.Insert(FULLSCAN_SELECTED_INDEX, CreateScanPoint(Color.Red));
            }
        }
Esempio n. 3
0
        private void DisplayTotals(IRegressionFunction timeRegressionFunction,
            ChromatogramSet chromatograms,
            float mzMatchTolerance,
            int countLabelTypes,
            ref double bestStartTime,
            ref double bestEndTime)
        {
            // Construct and add graph items for all relevant transition groups.
            float fontSize = FontSize;
            int lineWidth = LineWidth;
            int iCharge = -1;
            int? charge = null;
            var chromGroupInfos = ChromGroupInfos;
            for (int i = 0; i < _nodeGroups.Length; i++)
            {
                var nodeGroup = _nodeGroups[i];
                var chromGroupInfo = chromGroupInfos[i];
                if (chromGroupInfo == null)
                    continue;

                ChromFileInfoId fileId = chromatograms.FindFile(chromGroupInfo);

                // Collect the chromatogram info for the transition children
                // of this transition group.
                ChromatogramInfo infoPrimary = null;
                TransitionChromInfo tranPeakInfo = null;
                float maxPeakHeight = float.MinValue;
                var listChromInfo = new List<ChromatogramInfo>();
                foreach (TransitionDocNode nodeTran in nodeGroup.Children)
                {
                    var info = chromGroupInfo.GetTransitionInfo((float)nodeTran.Mz, mzMatchTolerance);
                    if (info == null)
                        continue;

                    listChromInfo.Add(info);

                    // Keep track of which chromatogram owns the tallest member of
                    // the peak on the document tree.
                    var transitionChromInfo = GetTransitionChromInfo(nodeTran, _chromIndex, fileId, 0);
                    if (transitionChromInfo == null)
                        continue;

                    if (transitionChromInfo.Height > maxPeakHeight)
                    {
                        maxPeakHeight = transitionChromInfo.Height;
                        tranPeakInfo = transitionChromInfo;
                        infoPrimary = info;
                    }

                    // Adjust best peak window used to zoom the graph to the best peak
                    AddBestPeakTimes(transitionChromInfo, ref bestStartTime, ref bestEndTime);
                }

                // If any transitions are present for this group, add a graph item to
                // the graph for it.
                if (listChromInfo.Count > 0)
                {
                    if (infoPrimary == null)
                        infoPrimary = listChromInfo[0];

                    // Sum the intensities of all transitions into the first chromatogram
                    infoPrimary.SumIntensities(listChromInfo);

                    // Apply any transform the user has chosen
                    infoPrimary.Transform(Transform);

                    int iColor = GetColorIndex(nodeGroup, countLabelTypes, ref charge, ref iCharge);
                    Color color = COLORS_GROUPS[iColor % COLORS_GROUPS.Length];

                    bool[] annotateAll = new bool[infoPrimary.NumPeaks];
                    for (int j = 0; j < annotateAll.Length; j++)
                    {
                        var peak = infoPrimary.GetPeak(j);
                        if (peak.IsForcedIntegration)
                            continue;

                        // Exclude any peaks between the boundaries of the chosen peak.
                        if (tranPeakInfo != null &&
                            tranPeakInfo.StartRetentionTime < peak.RetentionTime &&
                            peak.RetentionTime < tranPeakInfo.EndRetentionTime)
                            continue;
                        annotateAll[j] = true;
                    }
                    var graphItem = new ChromGraphItem(nodeGroup,
                                                       null,
                                                       infoPrimary,
                                                       tranPeakInfo,
                                                       timeRegressionFunction,
                                                       annotateAll,
                                                       null,
                                                       0,
                                                       false,
                                                       false,
                                                       0,
                                                       color,
                                                       fontSize,
                                                       lineWidth);
                    var graphPaneKey = new PaneKey(nodeGroup);
                    _graphHelper.AddChromatogram(graphPaneKey, graphItem);
                }
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Display summed transitions for multiple selected peptides.
        /// </summary>
        private void DisplayPeptides(IRegressionFunction timeRegressionFunction,
            ChromatogramSet chromatograms,
            float mzMatchTolerance,
            int countLabelTypes,
            IList<PeptideDocNode> peptideDocNodes,
            ref double bestStartTime,
            ref double bestEndTime,
            out double leftPeakWidth,
            out double rightPeakWidth)
        {
            leftPeakWidth = 0;
            rightPeakWidth = 0;

            // Construct and add graph items for all relevant transition groups.
            float fontSize = FontSize;
            int lineWidth = LineWidth;
            var chromGroupInfos = ChromGroupInfos;
            var lookupChromGroupInfoIndex = new Dictionary<int, int>(_nodeGroups.Length);
            for (int i = 0; i < _nodeGroups.Length; i++)
                lookupChromGroupInfoIndex[_nodeGroups[i].Id.GlobalIndex] = i;

            // Generate a unique short identifier for each peptide.
            var peptideNames = new Tuple<string,bool>[peptideDocNodes.Count];
            for (int i = 0; i < peptideDocNodes.Count; i++)
                peptideNames[i] = new Tuple<string,bool>(peptideDocNodes[i].RawTextId, peptideDocNodes[i].IsProteomic);
            var uniqueNames = new UniquePrefixGenerator(peptideNames, 3);

            var displayPeptides = new List<DisplayPeptide>();
            for (int peptideIndex = 0; peptideIndex < peptideDocNodes.Count; peptideIndex++)
            {
                var peptideDocNode = peptideDocNodes[peptideIndex];
                TransitionChromInfo bestPeakInfo = null;
                ChromatogramInfo sumInfo = null;
                float maxPeakHeight = float.MinValue;

                foreach (var precursor in peptideDocNode.TransitionGroups)
                {
                    int indexInfo;
                    if (!lookupChromGroupInfoIndex.TryGetValue(precursor.Id.GlobalIndex, out indexInfo))
                        continue;
                    var chromGroupInfo = chromGroupInfos[indexInfo];
                    if (chromGroupInfo == null)
                        continue;
                    ChromFileInfoId fileId = chromatograms.FindFile(chromGroupInfo);
                    foreach (var nodeTran in precursor.Transitions)
                    {
                        var info = chromGroupInfo.GetTransitionInfo((float)nodeTran.Mz, mzMatchTolerance);
                        if (info == null)
                            continue;
                        if (sumInfo == null)
                            sumInfo = info;
                        else
                        {
                            float[] sumTimes;
                            float[] sumIntensities;
                            if (!AddTransitions.Add(
                                info.Times, info.Intensities, sumInfo.Times, sumInfo.Intensities,
                                out sumTimes, out sumIntensities))
                                continue;
                            sumInfo = new ChromatogramInfo(sumTimes, sumIntensities);
                        }

                        // Keep track of which chromatogram owns the tallest member of
                        // the peak on the document tree.
                        var transitionChromInfo = GetTransitionChromInfo(nodeTran, _chromIndex, fileId, 0);
                        if (transitionChromInfo == null)
                            continue;

                        if (transitionChromInfo.Height > maxPeakHeight)
                        {
                            maxPeakHeight = transitionChromInfo.Height;
                            bestPeakInfo = transitionChromInfo;
                        }
                    }
                }

                if (sumInfo != null && bestPeakInfo != null)
                {
                    displayPeptides.Add(new DisplayPeptide
                    {
                        PeptideIndex = peptideIndex,
                        SumInfo = sumInfo,
                        BestPeakInfo = bestPeakInfo
                    });
                }
            }

            // Order the peptides by height of best peak.
            displayPeptides = displayPeptides.OrderByDescending(e => e.BestPeakInfo.Height).ToList();

            // Display only the top peptides.
            int lastPeptideIndex = Math.Min(MaxPeptidesDisplayed, displayPeptides.Count);
            var graphItems = new List<ChromGraphItem>();
            for (int i = lastPeptideIndex-1; i >= 0; i--) // smallest peaks first for good z-ordering in graph
            {
                var bestPeakInfo = displayPeptides[i].BestPeakInfo;
                var sumInfo = displayPeptides[i].SumInfo;
                var peptideDocNode = peptideDocNodes[displayPeptides[i].PeptideIndex];

                // Intersect best peak with summed transition.
                if (bestPeakInfo != null && sumInfo.Times.Length > 0)
                {
                    float startRetentionTime = Math.Max(bestPeakInfo.StartRetentionTime, sumInfo.Times[0]);
                    float endRetentionTime = Math.Min(bestPeakInfo.EndRetentionTime, sumInfo.Times[sumInfo.Times.Length - 1]);
                    if (endRetentionTime > startRetentionTime)
                    {
                        if (bestStartTime > startRetentionTime)
                        {
                            bestStartTime = startRetentionTime;
                            leftPeakWidth = endRetentionTime - startRetentionTime;
                        }
                        if (bestEndTime < endRetentionTime)
                        {
                            bestEndTime = endRetentionTime;
                            rightPeakWidth = endRetentionTime - startRetentionTime;
                        }
                        bestPeakInfo = new TransitionChromInfo(startRetentionTime, endRetentionTime);
                    }
                }

                // Get peptide graph color from SequenceTree.
                var peptideGraphInfo = _stateProvider.GetPeptideGraphInfo(peptideDocNode);
                Color color = peptideGraphInfo.Color;

                sumInfo.Transform(Transform);
                bool[] annotateAll = new bool[sumInfo.NumPeaks];
                ChromGraphItem graphItem = new ChromGraphItem(null,
                    null,
                    sumInfo,
                    bestPeakInfo,
                    timeRegressionFunction,
                    annotateAll,
                    null,
                    0,
                    false,
                    false,
                    0,
                    color,
                    fontSize,
                    lineWidth)
                {
                    CurveAnnotation = uniqueNames.GetUniquePrefix(peptideDocNode.RawTextId, peptideDocNode.IsProteomic),
                    IdPath = _groupPaths[displayPeptides[i].PeptideIndex],
                    GraphInfo = peptideGraphInfo
                };
                if (peptideGraphInfo.IsSelected)
                    graphItems.Insert(0, graphItem);
                else
                    graphItems.Add(graphItem);
            }

            foreach (var graphItem in graphItems)
            {
                var curveItem = _graphHelper.AddChromatogram(new PaneKey(), graphItem);
                // Make the fill color under the curve more opaque if the curve is selected.
                var fillAlpha = graphItem.GraphInfo.IsSelected ? 60 : 15;
                ((LineItem)curveItem).Line.Fill = new Fill(Color.FromArgb(fillAlpha, graphItem.GraphInfo.Color));
            }
        }
 private void AssertChromatogramWindow(SrmDocument document, ChromatogramSet chromatogramSet,
     double expectedStartTime, double expectedEndTime, params ChromatogramGroupInfo[] chromGroupInfos)
 {
     ChromatogramGroupInfo[] basePeakChromatograms;
     Assert.IsTrue(document.Settings.MeasuredResults.TryLoadAllIonsChromatogram(chromatogramSet, ChromExtractor.base_peak, true,
         out basePeakChromatograms));
     if (basePeakChromatograms.Length > 0)
     {
         double runStartTime = basePeakChromatograms.Min(chromGroup => chromGroup.Times[0]);
         double runEndTime =
             basePeakChromatograms.Max(chromGroup => chromGroup.Times[chromGroup.Times.Length - 1]);
         expectedStartTime = Math.Max(runStartTime, expectedStartTime);
         expectedEndTime = Math.Min(runEndTime, expectedEndTime);
     }
     const double delta = .15;
     foreach (var chromGroupInfo in chromGroupInfos)
     {
         double startTime = chromGroupInfo.Times[0];
         double endTime = chromGroupInfo.Times[chromGroupInfo.Times.Length - 1];
         if (Math.Abs(expectedStartTime - startTime) > delta)
         {
             Assert.AreEqual(expectedStartTime, startTime, delta);
         }
         if (Math.Abs(expectedEndTime - endTime) > delta)
         {
             Assert.AreEqual(expectedEndTime, endTime, delta);
         }
     }
 }
Esempio n. 6
0
 private void ExportGroupNode(PeptideDocNode peptideNode,
     TransitionGroupDocNode groupNode,
     ChromatogramSet chromatograms,
     ICollection<string> filesToExport,
     ICollection<ChromSource> chromSources,
     TextWriter writer,
     CultureInfo cultureInfo)
 {
     string peptideModifiedSequence = _settings.GetDisplayName(peptideNode);
     int precursorCharge = groupNode.TransitionGroup.PrecursorCharge;
     string labelType = groupNode.TransitionGroup.LabelType.Name;
     var filesInChrom = chromatograms.MSDataFilePaths.Select(path=>path.GetFileName()).ToList();
     // Don't load the chromatogram group if none of its files are being exported
     if (!filesInChrom.Where(filesToExport.Contains).Any())
         return;
     ChromatogramGroupInfo[] arrayChromInfo;
     if (!_measuredResults.TryLoadChromatogram(chromatograms, peptideNode, groupNode,
                                              _matchTolerance, true, out arrayChromInfo))
     {
         // TODO: Determine if this is a real error or just a missing node for this file
         // If the former throw an exception, if the latter continue
         return;
     }
     if (arrayChromInfo.Length != chromatograms.FileCount)
     {
         throw new InvalidDataException(string.Format(Resources.ChromatogramExporter_ExportGroupNode_One_or_more_missing_chromatograms_at_charge_state__0__of__1_,
                                        precursorCharge, peptideModifiedSequence));
     }
     foreach (var chromGroupInfo in arrayChromInfo)
     {
         string fileName = chromGroupInfo.FilePath.GetFileName();
         // Skip the files that have not been selected for export
         if (!filesToExport.Contains(fileName))
             continue;
         foreach (var nodeTran in groupNode.Transitions)
         {
             // TODO: Check a source attribute on the transition chrom info
             bool isMs1 = nodeTran.Transition.IsPrecursor() && !nodeTran.HasLoss;
             if (isMs1 && !chromSources.Contains(ChromSource.ms1))
                 continue;
             if (!isMs1 && !chromSources.Contains(ChromSource.fragment))
                 continue;
             int productCharge = nodeTran.Transition.Charge;
             float productMz = (float)nodeTran.Mz;
             var chromInfo = chromGroupInfo.GetTransitionInfo(productMz, _matchTolerance);
             // Sometimes a transition in the transition group does not have results for a particular file
             // If this happens just skip it for that file
             if (chromInfo == null)
                 continue;
             IList<float> times = chromInfo.Times;
             IList<float> intensities = chromInfo.Intensities;
             if (times.Count != intensities.Count || intensities.Count == 0)
             {
                 throw new InvalidDataException(string.Format(Resources.ChromatogramExporter_Export_Bad_chromatogram_data_for_charge__0__state_of_peptide__1_,
                                                precursorCharge, peptideModifiedSequence));
             }
             float tic = CalculateTic(times, intensities);
             string[] fieldArray =
             {
                 fileName,
                 peptideModifiedSequence,
                 System.Convert.ToString(precursorCharge, cultureInfo),
                 System.Convert.ToString(productMz, cultureInfo),
                 nodeTran.GetFragmentIonName(CultureInfo.InvariantCulture),
                 System.Convert.ToString(productCharge, cultureInfo),
                 labelType,
                 System.Convert.ToString(tic, cultureInfo)
             };
             FormatChromLine(writer, fieldArray, times, intensities, cultureInfo);
         }
     }
 }
Esempio n. 7
0
 private void SetRetentionTimeIndicators(ChromGraphItem chromGraphPrimary,
     SrmSettings settings,
     ChromatogramSet chromatograms,
     PeptideDocNode[] nodePeps,
     TransitionGroupDocNode[] nodeGroups,
     string lookupSequence,
     ExplicitMods lookupMods)
 {
     // FUTURE: Fix this when we can predict retention time for small molecules
     if (lookupSequence == null)
     {
         return;
     }
     SetRetentionTimePredictedIndicator(chromGraphPrimary, settings, chromatograms,
         nodePeps, lookupSequence, lookupMods);
     SetRetentionTimeIdIndicators(chromGraphPrimary, settings,
         nodeGroups, lookupSequence, lookupMods);
 }
Esempio n. 8
0
 public ManageResultsAction(ChromatogramSet chromatograms)
 {
     Chromatograms = chromatograms;
 }
Esempio n. 9
0
        public void MsDataFileUriEncodingTest()
        {
            var fname = "test.mzML";
            var pathSample = SampleHelp.EncodePath(fname, null, -1, null, true, false);
            var lockmassParametersA = new LockMassParameters(1.23, 3.45, 4.56);
            var lockmassParametersB = new LockMassParameters(1.23, null, 4.56);

            Assert.IsTrue(lockmassParametersA.CompareTo(LockMassParameters.EMPTY) > 0);
            Assert.IsTrue(lockmassParametersA.CompareTo(null) < 0);
            Assert.IsTrue(lockmassParametersB.CompareTo(lockmassParametersA) < 0);
            Assert.IsTrue(lockmassParametersA.CompareTo(new LockMassParameters(1.23, 3.45, 4.56)) == 0);

            var c = new ChromatogramSet("test", new[] { MsDataFileUri.Parse(pathSample) });
            Assert.AreEqual(fname, c.MSDataFilePaths.First().GetFilePath());
            Assert.IsTrue(c.MSDataFilePaths.First().GetCentroidMs1());
            Assert.IsFalse(c.MSDataFilePaths.First().GetCentroidMs2());

            pathSample = SampleHelp.EncodePath(fname, null, -1, lockmassParametersA,false,true);
            c = new ChromatogramSet("test", new[] { MsDataFileUri.Parse(pathSample) });
            Assert.AreEqual(lockmassParametersA, c.MSDataFilePaths.First().GetLockMassParameters());
            Assert.IsTrue(c.MSDataFilePaths.First().GetCentroidMs2());
            Assert.IsFalse(c.MSDataFilePaths.First().GetCentroidMs1());

            pathSample = SampleHelp.EncodePath(fname, "test_0", 1, lockmassParametersB,false,false);
            c = new ChromatogramSet("test", new[] { MsDataFileUri.Parse(pathSample) });
            Assert.AreEqual(lockmassParametersB, c.MSDataFilePaths.First().GetLockMassParameters());
            Assert.AreEqual("test_0", c.MSDataFilePaths.First().GetSampleName());
            Assert.AreEqual(1, c.MSDataFilePaths.First().GetSampleIndex());
            Assert.IsFalse(c.MSDataFilePaths.First().GetCentroidMs1());
            Assert.IsFalse(c.MSDataFilePaths.First().GetCentroidMs2());
        }
Esempio n. 10
0
        private static PeakMatch GetPeakMatch(SrmDocument doc, ChromatogramSet chromSet, IPathContainer fileInfo, TransitionGroupDocNode nodeTranGroup,
            PeakMatchData referenceTarget, IEnumerable<PeakMatchData> referenceMatchData)
        {
            if (referenceTarget == null)
                return new PeakMatch(0, 0);

            var mzMatchTolerance = (float) doc.Settings.TransitionSettings.Instrument.MzMatchTolerance;

            ChromatogramGroupInfo[] loadInfos;
            if (!nodeTranGroup.HasResults || !doc.Settings.MeasuredResults.TryLoadChromatogram(chromSet, null, nodeTranGroup, mzMatchTolerance, true, out loadInfos))
                return null;

            var chromGroupInfo = loadInfos.FirstOrDefault(info => Equals(info.FilePath, fileInfo.FilePath));
            if (chromGroupInfo == null || chromGroupInfo.NumPeaks == 0 || !chromGroupInfo.Times.Any())
                return null;

            var matchData = new List<PeakMatchData>();
            double totalArea = chromGroupInfo.TransitionPointSets.Sum(chromInfo => chromInfo.Peaks.Sum(peak => peak.Area));
            for (int i = 0; i < chromGroupInfo.NumPeaks; i++)
                matchData.Add(new PeakMatchData(nodeTranGroup, chromGroupInfo, mzMatchTolerance, i, totalArea));

            // TODO: Try to improve this. Align peaks in area descending order until peaks do not match
            var alignments = new List<PeakAlignment>();
            bool referenceAligned = false;
            var referenceIter = referenceMatchData.OrderByDescending(d => d.PercentArea).GetEnumerator();
            var curIter = matchData.OrderByDescending(d => d.PercentArea).GetEnumerator();
            while (referenceIter.MoveNext() && curIter.MoveNext())
            {
                var alignAttempt = new PeakAlignment(referenceIter.Current, curIter.Current);
                if (!TryInsertPeakAlignment(alignments, alignAttempt))
                    break;

                if (referenceTarget == alignAttempt.ReferencePeak)
                {
                    // Reference target aligned
                    referenceAligned = true;
                    matchData = new List<PeakMatchData> {alignAttempt.AlignedPeak};
                    break;
                }
            }

            PeakMatch manualMatch = null;

            if (!referenceAligned)
            {
                PeakAlignment prev, next;
                GetSurroundingAlignments(alignments, referenceTarget, out prev, out next);
                if (prev != null || next != null)
                {
                    // At least one alignment occurred
                    var chromGroupMinTime = chromGroupInfo.Times.First();
                    var chromGroupMaxTime = chromGroupInfo.Times.Last();

                    float scale = (chromGroupMaxTime - chromGroupMinTime)/(referenceTarget.MaxTime - referenceTarget.MinTime);
                    manualMatch = MakePeakMatchBetween(scale, referenceTarget, prev, next);
                    if (chromGroupMinTime >= manualMatch.EndTime || manualMatch.StartTime >= chromGroupMaxTime)
                        manualMatch = null;

                    float curMinTime = prev == null ? chromGroupMinTime : prev.AlignedPeak.RetentionTime;
                    float curMaxTime = next == null ? chromGroupMaxTime : next.AlignedPeak.RetentionTime;

                    matchData = matchData.Where(d => curMinTime < d.RetentionTime && d.RetentionTime < curMaxTime).ToList();
                }
            }

            PeakMatchData bestMatch = null;
            double bestScore = double.MinValue;
            foreach (var other in matchData)
            {
                var score = referenceTarget.GetMatchScore(other);
                if (bestMatch == null || score > bestScore)
                {
                    bestScore = score;
                    bestMatch = other;
                }
            }

            // If no matching peak with high enough score was found, but there is a matching
            // peak or some peak with a low score.
            if (bestMatch == null || (!referenceAligned && bestScore < INTEGRATE_SCORE_THRESHOLD && manualMatch != null))
                return manualMatch;

            if (referenceTarget.ShiftLeft == 0 && referenceTarget.ShiftRight == 0)
                return new PeakMatch(bestMatch.RetentionTime);

            var range = bestMatch.EndTime - bestMatch.StartTime;
            var startTime = bestMatch.StartTime + (referenceTarget.ShiftLeft*range);
            var endTime = bestMatch.EndTime + (referenceTarget.ShiftRight*range);
            return startTime <= bestMatch.RetentionTime && bestMatch.RetentionTime <= endTime
                ? new PeakMatch(startTime, endTime)
                : new PeakMatch(bestMatch.RetentionTime); // If the shifted boundaries exclude the peak itself, don't change the boundaries
        }
Esempio n. 11
0
 public GroupIdentifier GetGroupIdentifier(SrmSettings settings, ChromatogramSet chromatogramSet)
 {
     AnnotationDef annotationDef =
         settings.DataSettings.AnnotationDefs.FirstOrDefault(a => a.Name == ControlAnnotation);
     if (annotationDef == null)
     {
         return default(GroupIdentifier);
     }
     return GroupIdentifier.MakeGroupIdentifier(chromatogramSet.Annotations.GetAnnotation(annotationDef));
 }
 private ChromatogramSet StripPathInfo(ChromatogramSet chromatogramSet)
 {
     return chromatogramSet.ChangeMSDataFileInfos(chromatogramSet.MSDataFileInfos
         .Select(StripFilePathInfo).ToArray());
 }
Esempio n. 13
0
        private SrmDocument ImportResults(SrmDocument doc, string nameResult, IEnumerable<MsDataFileUri> dataSources,
            OptimizableRegression optimizationFunction)
        {
            var results = doc.Settings.MeasuredResults;
            var chrom = GetChromatogramByName(nameResult, results);
            if (chrom == null)
            {
                // If the chromatogram, is not in the current set, then delete the cache
                // file to make sure it is not on disk before starting.
                FileEx.SafeDelete(ChromatogramCache.FinalPathForName(DocumentFilePath, nameResult), true);

                chrom = new ChromatogramSet(nameResult, dataSources, Annotations.EMPTY, optimizationFunction);

                if (results == null)
                    results = new MeasuredResults(new[] {chrom});
                else
                {
                    // Add the new result to the end.
                    var listChrom = new List<ChromatogramSet>(results.Chromatograms) {chrom};
                    results = results.ChangeChromatograms(listChrom.ToArray());
                }
            }
            else
            {
                // Append to an existing chromatogram set
                var dataFilePaths = new List<MsDataFileUri>(chrom.MSDataFilePaths);
                foreach (var sourcePath in dataSources)
                {
                    if (!dataFilePaths.Contains(sourcePath))
                        dataFilePaths.Add(sourcePath);
                }
                // If no new paths added, just return without changing.
                if (dataFilePaths.Count == chrom.FileCount)
                    return doc;

                int replaceIndex = results.Chromatograms.IndexOf(chrom);
                var arrayChrom = results.Chromatograms.ToArray();
                arrayChrom[replaceIndex] = chrom.ChangeMSDataFilePaths(dataFilePaths);

                results = results.ChangeChromatograms(arrayChrom);
            }

            if (results != null && Program.DisableJoining)
                results = results.ChangeIsJoiningDisabled(true);

            return doc.ChangeMeasuredResults(results);
        }
 private IEnumerable<Tuple<PeptideDocNode, TransitionGroupDocNode, ChromatogramGroupInfo[]>> LoadAllChromatograms(SrmDocument document, ChromatogramSet chromatogramSet)
 {
     foreach (var peptide in document.Molecules)
     {
         foreach (var transitionGroup in peptide.TransitionGroups)
         {
             ChromatogramGroupInfo[] infos;
             document.Settings.MeasuredResults.TryLoadChromatogram(chromatogramSet, peptide, transitionGroup,
                 (float) TransitionInstrument.DEFAULT_MZ_MATCH_TOLERANCE, true, out infos);
             yield return new Tuple<PeptideDocNode, TransitionGroupDocNode, ChromatogramGroupInfo[]>(peptide, transitionGroup, infos);
         }
     }
 }
Esempio n. 15
0
        private bool EnsureChromInfo(MeasuredResults results,
            ChromatogramSet chromatograms,
            TransitionGroupDocNode[] nodeGroups,
            IdentityPath[] groupPaths,
            ChromExtractor extractor,
            out bool changedGroups,
            out bool changedGroupIds)
        {
            if (UpdateGroups(nodeGroups, groupPaths, out changedGroups, out changedGroupIds) && _extractor == extractor)
                return true;

            _extractor = extractor;

            bool success = false;
            try
            {
                // Get chromatogram sets for all transition groups, recording unique
                // file paths in the process.
                var listArrayChromInfo = new List<ChromatogramGroupInfo[]>();
                var listFiles = new List<MsDataFileUri>();
                ChromatogramGroupInfo[] arrayAllIonsChromInfo;
                if (!results.TryLoadAllIonsChromatogram(chromatograms, extractor, true,
                                                        out arrayAllIonsChromInfo))
                {
                    return false;
                }
                else
                {
                    listArrayChromInfo.Add(arrayAllIonsChromInfo);
                    foreach (var chromInfo in arrayAllIonsChromInfo)
                    {
                        var filePath = chromInfo.FilePath;
                        if (!listFiles.Contains(filePath))
                            listFiles.Add(filePath);
                    }
                }

                _hasMergedChromInfo = false;
                _arrayChromInfo = new ChromatogramGroupInfo[listFiles.Count][];
                for (int i = 0; i < _arrayChromInfo.Length; i++)
                {
                    var arrayNew = new ChromatogramGroupInfo[listArrayChromInfo.Count];
                    for (int j = 0; j < arrayNew.Length; j++)
                    {
                        var arrayChromInfo = listArrayChromInfo[j];
                        if (arrayChromInfo == null)
                            continue;
                        foreach (var chromInfo in arrayChromInfo)
                        {
                            if (arrayNew[j] == null && Equals(listFiles[i], chromInfo.FilePath))
                                arrayNew[j] = chromInfo;
                        }
                    }
                    _arrayChromInfo[i] = arrayNew;
                }

                success = true;
            }
            finally
            {
                // Make sure the info array is set to null on failure.
                if (!success)
                    _arrayChromInfo = null;
            }

            return true;
        }
Esempio n. 16
0
 public void ChangeChromatogramSet(EditDescription editDescription, ChromatogramSet chromatogramSet)
 {
     ModifyDocument(editDescription, document =>
         {
             var measuredResults = document.Settings.MeasuredResults;
             var chromatograms = measuredResults.Chromatograms.ToArray();
             chromatograms[ReplicateIndex] = chromatogramSet;
             measuredResults = measuredResults.ChangeChromatograms(chromatograms);
             return document.ChangeMeasuredResults(measuredResults);
         }
     );
 }
Esempio n. 17
0
        private bool EnsureChromInfo(MeasuredResults results,
            ChromatogramSet chromatograms,
            PeptideDocNode[] nodePeps,
            TransitionGroupDocNode[] nodeGroups,
            IdentityPath[] groupPaths,
            float mzMatchTolerance,
            out bool changedGroups,
            out bool changedGroupIds)
        {
            if (UpdateGroups(nodeGroups, groupPaths, out changedGroups, out changedGroupIds) && !_extractor.HasValue)
                return true;

            _extractor = null;

            bool success = false;
            try
            {
                // Get chromatogram sets for all transition groups, recording unique
                // file paths in the process.
                var listArrayChromInfo = new List<ChromatogramGroupInfo[]>();
                var listFiles = new List<MsDataFileUri>();
                for (int i = 0; i < nodeGroups.Length; i++)
                {
                    ChromatogramGroupInfo[] arrayChromInfo;
                    if (!results.TryLoadChromatogram(
                        chromatograms,
                        nodePeps[i],
                        nodeGroups[i],
                        mzMatchTolerance,
                        true,
                        out arrayChromInfo))
                    {
                        listArrayChromInfo.Add(null);
                        continue;
                    }

                    listArrayChromInfo.Add(arrayChromInfo);
                    foreach (var chromInfo in arrayChromInfo)
                    {
                        var filePath = chromInfo.FilePath;
                        if (!listFiles.Contains(filePath))
                            listFiles.Add(filePath);
                    }
                }

                // If no data was found, then return false
                if (listFiles.Count == 0)
                    return false;

                // Make a list of chromatogram info by unique file path corresponding
                // to the groups passed in.
                _arrayChromInfo = new ChromatogramGroupInfo[listFiles.Count][];
                for (int i = 0; i < _arrayChromInfo.Length; i++)
                {
                    var arrayNew = new ChromatogramGroupInfo[listArrayChromInfo.Count];
                    for (int j = 0; j < arrayNew.Length; j++)
                    {
                        var arrayChromInfo = listArrayChromInfo[j];
                        if (arrayChromInfo == null)
                            continue;
                        foreach (var chromInfo in arrayChromInfo)
                        {
                            if (arrayNew[j] == null && Equals(listFiles[i], chromInfo.FilePath))
                                arrayNew[j] = chromInfo;
                        }
                    }
                    _arrayChromInfo[i] = arrayNew;
                }

                // If multiple replicate files contain mutually exclusive data, create "all files" option.
                var mergedChromGroupInfo = GetMergedChromInfo();
                _hasMergedChromInfo = (mergedChromGroupInfo != null);
                if (_hasMergedChromInfo)
                {
                    var arrayNew = new ChromatogramGroupInfo[_arrayChromInfo.Length + 1][];
                    arrayNew[0] = mergedChromGroupInfo;
                    for (int i = 1; i < arrayNew.Length; i++)
                        arrayNew[i] = _arrayChromInfo[i - 1];
                    _arrayChromInfo = arrayNew;
                }

                success = true;
            }
            finally
            {
                // Make sure the info array is set to null on failure.
                if (!success)
                    _arrayChromInfo = null;
            }

            return true;
        }
Esempio n. 18
0
        private static void SetRetentionTimePredictedIndicator(ChromGraphItem chromGraphPrimary,
            SrmSettings settings,
            ChromatogramSet chromatograms,
            PeptideDocNode[] nodePeps,
            string lookupSequence,
            ExplicitMods lookupMods)
        {
            // Set predicted retention time on the first graph item to make
            // line, label and shading show.
            var regression = settings.PeptideSettings.Prediction.RetentionTime;
            if (regression != null && Settings.Default.ShowRetentionTimePred)
            {
                string modSeq = settings.GetModifiedSequence(lookupSequence, IsotopeLabelType.light, lookupMods);
                var fileId = chromatograms.FindFile(chromGraphPrimary.Chromatogram);
                double? predictedRT = regression.GetRetentionTime(modSeq, fileId);
                double window = regression.TimeWindow;

                chromGraphPrimary.RetentionPrediction = predictedRT;
                chromGraphPrimary.RetentionWindow = window;
            }
            chromGraphPrimary.RetentionExplicit = (nodePeps.Length == 1) ? nodePeps[0].ExplicitRetentionTime : null;
        }
 public ListBoxItem(ChromatogramSet chromatogramSet)
 {
     ChromatogramSet = chromatogramSet;
 }
Esempio n. 20
0
        private void DisplayAllIonsSummary(IRegressionFunction timeRegressionFunction,
            TransitionDocNode nodeTranSelected,
            ChromatogramSet chromatograms,
            ChromExtractor extractor,
            ref double bestStartTime,
            ref double bestEndTime)
        {
            if (ChromGroupInfos.Length == 0)
            {
                return;
            }
            var chromGroupInfo = ChromGroupInfos[0];
            var info = chromGroupInfo.GetTransitionInfo(0, 0);
            var fileId = chromatograms.FindFile(chromGroupInfo);

            var nodeGroup = _nodeGroups != null ? _nodeGroups[0] : null;
            if (nodeGroup == null)
                nodeTranSelected = null;

            TransitionChromInfo tranPeakInfo = null;
            if (nodeGroup != null)
            {
                float maxPeakHeight = float.MinValue;
                foreach (TransitionDocNode nodeTran in nodeGroup.Children)
                {
                    // Keep track of which chromatogram owns the tallest member of
                    // the peak on the document tree.
                    var transitionChromInfo = GetTransitionChromInfo(nodeTran, _chromIndex, fileId, 0);
                    if (transitionChromInfo == null)
                        continue;

                    if (nodeTranSelected != null)
                    {
                        if (ReferenceEquals(nodeTran, nodeTranSelected))
                            tranPeakInfo = transitionChromInfo;
                    }
                    else if (transitionChromInfo.Height > maxPeakHeight)
                    {
                        maxPeakHeight = transitionChromInfo.Height;
                        tranPeakInfo = transitionChromInfo;
                    }

                    // Adjust best peak window used to zoom the graph to the best peak
                    AddBestPeakTimes(transitionChromInfo, ref bestStartTime, ref bestEndTime);
                }
            }

            // Apply active transform
            info.Transform(Transform);

            int numPeaks = info.NumPeaks;
            var annotationFlags = new bool[numPeaks];
            for (int i = 0; i < numPeaks; i++)
            {
                // Exclude any peaks between the boundaries of the chosen peak.
                annotationFlags[i] = !IntersectPeaks(info.GetPeak(i), tranPeakInfo);
            }
            var graphItem = new ChromGraphItem(nodeGroup,
                                               nodeTranSelected,
                                               info,
                                               tranPeakInfo,
                                               timeRegressionFunction,
                                               annotationFlags,
                                               null,
                                               0,
                                               true,
                                               true,
                                               0,
                                               COLORS_GROUPS[(int)extractor],
                                               FontSize,
                                               LineWidth);
            _graphHelper.AddChromatogram(new PaneKey(nodeGroup), graphItem);
        }
Esempio n. 21
0
 public bool Equals(ChromatogramSet obj)
 {
     if (ReferenceEquals(null, obj)) return false;
     if (ReferenceEquals(this, obj)) return true;
     // Why isn't "OptimizationFunction" included in "Equals"?
     if (!base.Equals(obj))
         return false;
     if (!ArrayUtil.EqualsDeep(obj.MSDataFileInfos, MSDataFileInfos))
         return false;
     if (!Equals(obj.Annotations, Annotations))
         return false;
     if (!obj.UseForRetentionTimeFilter == UseForRetentionTimeFilter)
         return false;
     if (!Equals(obj.OptimizationFunction, OptimizationFunction))
         return false;
     if (obj._rescoreCount != _rescoreCount)
         return false;
     if (!Equals(obj.AnalyteConcentration, AnalyteConcentration))
         return false;
     if (!Equals(obj.SampleType, SampleType))
         return false;
     return true;
 }
Esempio n. 22
0
        private void DisplayOptimizationTotals(IRegressionFunction timeRegressionFunction,
            ChromatogramSet chromatograms,
            float mzMatchTolerance,
            ref double bestStartTime,
            ref double bestEndTime)
        {
            // Construct and add graph items for all relevant transition groups.
            float fontSize = FontSize;
            int lineWidth = LineWidth;
            int iColor = 0;

            // Get the one and only group
            var nodeGroup = _nodeGroups[0];
            var chromGroupInfo = ChromGroupInfos[0];
            ChromFileInfoId fileId = chromatograms.FindFile(chromGroupInfo);

            int numPeaks = chromGroupInfo.NumPeaks;

            // Collect the chromatogram info for the transition children
            // of this transition group.
            var listChromInfoSets = new List<ChromatogramInfo[]>();
            var listTranisitionChromInfoSets = new List<TransitionChromInfo[]>();
            int totalOptCount = chromatograms.OptimizationFunction.StepCount*2 + 1;
            foreach (TransitionDocNode nodeTran in nodeGroup.Children)
            {
                var infos = chromGroupInfo.GetAllTransitionInfo((float) nodeTran.Mz, mzMatchTolerance,
                                                                chromatograms.OptimizationFunction);
                if (infos.Length == 0)
                    continue;

                // Make sure the total number of chrom info entries match the expected
                // no matter what, so that chromatogram colors will match up with peak
                // area charts.
                if (infos.Length != totalOptCount)
                    infos = ResizeArrayChromInfo(infos, totalOptCount);

                listChromInfoSets.Add(infos);
                var transitionChromInfos = new TransitionChromInfo[totalOptCount];
                int steps = infos.Length/2;
                int offset = totalOptCount/2 - steps;
                for (int i = 0; i < infos.Length; i++)
                {
                    transitionChromInfos[i + offset] = GetTransitionChromInfo(nodeTran, _chromIndex, fileId, i - steps);
                }
                listTranisitionChromInfoSets.Add(transitionChromInfos);
            }

            if (listChromInfoSets.Count == 0 || totalOptCount == 0)
                throw new InvalidDataException(Resources.GraphChromatogram_DisplayOptimizationTotals_No_optimization_data_available);

            // Enumerate optimization steps, grouping the data into graph data by step
            var listGraphData = new List<OptimizationGraphData>();
            for (int i = 0; i < listChromInfoSets.Count; i++)
            {
                var chromInfos = listChromInfoSets[i];
                var transitionChromInfos = listTranisitionChromInfoSets[i];

                for (int j = 0; j < chromInfos.Length; j++)
                {
                    if (listGraphData.Count <= j)
                        listGraphData.Add(new OptimizationGraphData(numPeaks));
                    listGraphData[j].Add(chromInfos[j], transitionChromInfos[j]);
                }
            }

            // Total and transform the data, and compute which optimization
            // set has the most intense peak for each peak group.
            int bestPeakData = -1;
            TransitionChromInfo tranPeakInfo = null;
            float maxPeakHeight = float.MinValue;
            var maxPeakData = new int[numPeaks];
            var maxPeakHeights = new float[numPeaks];
            for (int i = 0; i < numPeaks; i++)
                maxPeakHeights[i] = float.MinValue;
            var transform = Transform;
            for (int i = 0; i < listGraphData.Count; i++)
            {
                var graphData = listGraphData[i];
                var infoPrimary = graphData.InfoPrimary;
                if (infoPrimary == null)
                    continue;

                // Sum intensities of all transitions in this
                // optimization bucket
                infoPrimary.SumIntensities(graphData.ChromInfos);

                // Apply any transform the user has chosen
                infoPrimary.Transform(transform);

                for (int j = 0; j < numPeaks; j++)
                {
                    float height = graphData.PeakHeights[j];
                    if (height > maxPeakHeights[j])
                    {
                        maxPeakHeights[j] = height;
                        maxPeakData[j] = i;
                    }
                }

                if (maxPeakHeight < graphData.TotalHeight)
                {
                    maxPeakHeight = graphData.TotalHeight;
                    bestPeakData = i;
                    tranPeakInfo = graphData.TransitionInfoPrimary;
                }
                AddBestPeakTimes(graphData.TransitionInfoPrimary, ref bestStartTime, ref bestEndTime);
            }

            // Hide all peaks between the best peak extents
            if (tranPeakInfo != null)
            {
                for (int j = 0; j < numPeaks; j++)
                {
                    if (maxPeakHeights[j] == 0)
                        continue;
                    var graphData = listGraphData[maxPeakData[j]];
                    if (graphData.InfoPrimary == null)
                        continue;

                    ChromPeak peak = graphData.InfoPrimary.GetPeak(j);
                    if (peak.IsForcedIntegration)
                        continue;

                    if (IntersectPeaks(peak, tranPeakInfo))
                        maxPeakHeights[j] = 0;
                }
            }

            // Create graph items
            int totalSteps = totalOptCount/2;
            for (int i = 0; i < listGraphData.Count; i++)
            {
                var graphData = listGraphData[i];

                if (graphData.InfoPrimary != null)
                {
                    int step = i - totalSteps;
                    int width = lineWidth;
                    Color color;
                    if (step == 0)
                    {
                        color = ChromGraphItem.ColorSelected;
                        width++;
                    }
                    else if (nodeGroup.HasLibInfo)
                        color = COLORS_LIBRARY[iColor % COLORS_LIBRARY.Length];
                    else
                        color = COLORS_LIBRARY[iColor % COLORS_LIBRARY.Length];
                    //                                color = COLORS_HEURISTIC[iColor % COLORS_HEURISTIC.Length];

                    TransitionChromInfo tranPeakInfoGraph = null;
                    if (bestPeakData == i)
                        tranPeakInfoGraph = tranPeakInfo;
                    var graphItem = new ChromGraphItem(nodeGroup,
                                                       null,
                                                       graphData.InfoPrimary,
                                                       tranPeakInfoGraph,
                                                       timeRegressionFunction,
                                                       GetAnnotationFlags(i, maxPeakData, maxPeakHeights),
                                                       null,
                                                       0,
                                                       false,
                                                       false,
                                                       step,
                                                       color,
                                                       fontSize,
                                                       width);
                    _graphHelper.AddChromatogram(PaneKey.PRECURSORS, graphItem);
                }

                iColor++;
            }
        }
Esempio n. 23
0
 public DateTime? GetRunStartTime(ChromatogramSet chromatogramSet)
 {
     DateTime? runStartTime = null;
     foreach (var fileInfo in chromatogramSet.MSDataFileInfos)
     {
         if (!fileInfo.RunStartTime.HasValue)
         {
             continue;
         }
         if (!runStartTime.HasValue || runStartTime.Value > fileInfo.RunStartTime.Value)
         {
             runStartTime = fileInfo.RunStartTime;
         }
     }
     return runStartTime;
 }
 public double? GetPeptideConcentration(ChromatogramSet chromatogramSet)
 {
     double concentrationMultiplier = PeptideQuantifier.PeptideDocNode.ConcentrationMultiplier.GetValueOrDefault(1.0);
     return chromatogramSet.AnalyteConcentration*concentrationMultiplier;
 }