示例#1
0
        public static RatioPropertyDescriptor GetProperty(SrmDocument document, Type componentType, string propertyName)
        {
            string         prefix;
            IList <string> parts;

            if (!TryParseProperty(propertyName, out prefix, out parts))
            {
                return(null);
            }
            var modifications = document.Settings.PeptideSettings.Modifications;

            if (componentType == typeof(PeptideResult))
            {
                string displayName;
                Func <PeptideResult, double?> getterFunc;
                if (parts.Count == 0)
                {
                    return(null);
                }
                string format;
                string labelColumnPart = parts[0];
                var    labelType       = FindLabel(modifications.GetModificationTypes(), labelColumnPart);
                if (parts.Count == 1)
                {
                    getterFunc = peptideResult =>
                                 RatioValue.GetRatio(FindPeptideLabelRatio(peptideResult, labelType, null).Ratio);
                    displayName = string.Format("Ratio{0}ToGlobalStandards", labelColumnPart); // Not L10N
                    format      = Formats.GLOBAL_STANDARD_RATIO;
                }
                else if (parts.Count != 2)
                {
                    return(null);
                }
                else
                {
                    string standardColumnPart = parts[1];
                    var    standardType       = FindLabel(modifications.RatioInternalStandardTypes, standardColumnPart);
                    if (prefix == RATIO_PREFIX)
                    {
                        getterFunc = peptideResult =>
                                     RatioValue.GetRatio(FindPeptideLabelRatio(peptideResult, labelType, standardType).Ratio);
                        displayName = string.Format("Ratio{0}To{1}", labelColumnPart, standardColumnPart); // Not L10N
                        format      = Formats.STANDARD_RATIO;
                    }
                    else if (prefix == RDOTP_PREFIX)
                    {
                        getterFunc = peptideResult =>
                                     RatioValue.GetDotProduct(FindPeptideLabelRatio(peptideResult, labelType, standardType).Ratio);
                        displayName = string.Format("DotProduct{0}To{1}", labelColumnPart, standardColumnPart); // Not L10N
                        format      = Formats.STANDARD_RATIO;
                    }
                    else
                    {
                        return(null);
                    }
                }
                return(MakeRatioProperty(propertyName, displayName, format, getterFunc));
            }
            if (componentType == typeof(PrecursorResult))
            {
                string format;
                Func <PrecursorResult, double?> getterFunc;
                string displayName;
                if (parts.Count == 0)
                {
                    if (prefix != RATIO_GS_PREFIX)
                    {
                        return(null);
                    }
                    getterFunc  = precursorResult => RatioValue.GetRatio(precursorResult.ChromInfo.Ratios[precursorResult.ChromInfo.Ratios.Count - 1]);
                    displayName = "TotalAreaRatioToGlobalStandards"; // Not L10N
                    format      = Formats.GLOBAL_STANDARD_RATIO;
                }
                else if (parts.Count != 1)
                {
                    return(null);
                }
                else
                {
                    format = Formats.STANDARD_RATIO;
                    string labelColumnPart = parts[0];
                    int    ratioIndex      = IndexOf(modifications.RatioInternalStandardTypes, labelColumnPart);
                    if (prefix == RATIO_PREFIX)
                    {
                        getterFunc = precursorResult =>
                        {
                            if (ratioIndex < 0 || ratioIndex >= precursorResult.ChromInfo.Ratios.Count)
                            {
                                return(null);
                            }
                            return(RatioValue.GetRatio(precursorResult.ChromInfo.Ratios[ratioIndex]));
                        };
                        displayName = string.Format("TotalAreaRatioTo{0}", labelColumnPart); // Not L10N
                    }
                    else if (prefix == RDOTP_PREFIX)
                    {
                        getterFunc = precursorResult =>
                        {
                            if (ratioIndex < 0 || ratioIndex >= precursorResult.ChromInfo.Ratios.Count)
                            {
                                return(null);
                            }
                            return(RatioValue.GetDotProduct(precursorResult.ChromInfo.Ratios[ratioIndex]));
                        };
                        displayName = string.Format("DotProductTo{0}", labelColumnPart); // Not L10N
                    }
                    else
                    {
                        return(null);
                    }
                }
                return(MakeRatioProperty(propertyName, displayName, format, getterFunc));
            }
            if (componentType == typeof(TransitionResult))
            {
                string format;
                Func <TransitionResult, double?> getterFunc;
                string displayName;
                if (parts.Count == 0)
                {
                    if (prefix != RATIO_GS_PREFIX)
                    {
                        return(null);
                    }

                    getterFunc  = transitionResult => transitionResult.ChromInfo.Ratios[transitionResult.ChromInfo.Ratios.Count - 1];
                    displayName = "AreaRatioToGlobalStandards"; // Not L10N
                    format      = Formats.GLOBAL_STANDARD_RATIO;
                }
                else if (prefix != RATIO_PREFIX || parts.Count != 1)
                {
                    return(null);
                }
                else
                {
                    format = Formats.STANDARD_RATIO;
                    string labelColumnPart = parts[0];
                    int    ratioIndex      = IndexOf(modifications.RatioInternalStandardTypes, labelColumnPart);
                    getterFunc = transitionResult =>
                    {
                        if (ratioIndex < 0 || ratioIndex >= transitionResult.ChromInfo.Ratios.Count)
                        {
                            return(null);
                        }
                        return(transitionResult.ChromInfo.Ratios[ratioIndex]);
                    };
                    displayName = string.Format("AreaRatioTo{0}", labelColumnPart); // Not L10N
                }
                return(MakeRatioProperty(propertyName, displayName, format, getterFunc));
            }
            return(null);
        }
示例#2
0
        private void TestRatioFilter()
        {
            const double filterValue = 5.0;

            RunUI(() =>
            {
                SkylineWindow.OpenFile(TestFilesDir.GetTestPath("MultiLabel.sky"));
                SkylineWindow.ShowDocumentGrid(true);
            });
            DocumentGridForm documentGrid = FindOpenForm <DocumentGridForm>();

            RunUI(() => documentGrid.ChooseView(Resources.SkylineViewContext_GetDocumentGridRowSources_Precursors));
            var modifications = SkylineWindow.Document.Settings.PeptideSettings.Modifications;
            var isotopeLabel  = modifications.InternalStandardTypes.First(
                label => label.Name == "heavy 15N");

            AddFilter(documentGrid, PropertyPath.Parse("Proteins!*.Peptides!*.Precursors!*.Results!*.Value")
                      .Property(RatioPropertyDescriptor.MakePropertyName(RatioPropertyDescriptor.RATIO_PREFIX, isotopeLabel)),
                      FilterOperations.OP_IS_GREATER_THAN_OR_EQUAL,
                      filterValue.ToString(CultureInfo.CurrentCulture));
            RunUI(() =>
            {
                var colPeptide       = documentGrid.FindColumn(PropertyPath.Parse("Peptide"));
                var filteredPeptides = Enumerable.Range(0, documentGrid.RowCount).Select(
                    rowIndex => (Peptide)documentGrid.DataGridView.Rows[rowIndex].Cells[colPeptide.Index].Value)
                                       .ToArray();
                CollectionAssert.AreEqual(new [] { "AEVAALAAENK", "AIDYVEATANSHSR" },
                                          filteredPeptides.Select(peptide => peptide.ToString()).ToArray());
                var allPeptides = new Peptides(new SkylineDataSchema(SkylineWindow, DataSchemaLocalizer.INVARIANT), new [] { IdentityPath.ROOT });
                var ratioIndex  = modifications.InternalStandardTypes.IndexOf(isotopeLabel);
                Assert.IsTrue(ratioIndex >= 0);
                foreach (var peptide in allPeptides.GetItems().OfType <Peptide>())
                {
                    var peptidePath = peptide.IdentityPath;
                    bool hasMatchingPrecursorResult =
                        peptide.Precursors.Any(
                            precursor =>
                            precursor.Results.Values.Any(
                                precursorResult =>
                                RatioValue.GetRatio(precursorResult.ChromInfo.Ratios[ratioIndex]) >= filterValue));
                    Assert.AreEqual(hasMatchingPrecursorResult, filteredPeptides.Any(filteredPeptide => filteredPeptide.IdentityPath.Equals(peptidePath)));
                }
            }
                  );
            RunUI(() => documentGrid.ChooseView(Resources.SkylineViewContext_GetDocumentGridRowSources_Precursors));
            WaitForConditionUI(() => documentGrid.IsComplete);
            Assert.AreEqual(12, documentGrid.RowCount);
            {
                var quickFilterForm = ShowDialog <QuickFilterForm>(() =>
                {
                    var precursorMzColumn = documentGrid.FindColumn(PropertyPath.Root.Property("Mz"));
                    documentGrid.QuickFilter(precursorMzColumn);
                });
                RunUI(() =>
                {
                    quickFilterForm.SetFilterOperation(0, FilterOperations.OP_IS_GREATER_THAN);
                    quickFilterForm.SetFilterOperand(0, 500.5.ToString(CultureInfo.CurrentCulture));
                    quickFilterForm.SetFilterOperation(1, FilterOperations.OP_IS_LESS_THAN);
                    quickFilterForm.SetFilterOperand(1, 600.5.ToString(CultureInfo.CurrentCulture));
                });
                OkDialog(quickFilterForm, quickFilterForm.OkDialog);
            }
            WaitForConditionUI(() => documentGrid.IsComplete);
            Assert.AreEqual(8, documentGrid.RowCount);
            {
                var quickFilterForm = ShowDialog <QuickFilterForm>(() =>
                {
                    var precursorMzColumn = documentGrid.FindColumn(PropertyPath.Root.Property("Mz"));
                    documentGrid.QuickFilter(precursorMzColumn);
                });
                RunUI(() =>
                {
                    quickFilterForm.SetFilterOperand(0, "invalidnumber");
                });
                var messageDlg = ShowDialog <AlertDlg>(quickFilterForm.OkDialog);
                OkDialog(messageDlg, messageDlg.OkDialog);
                OkDialog(quickFilterForm, quickFilterForm.CancelButton.PerformClick);
            }
        }