Beispiel #1
0
 /// <summary>
 /// Initializes digestion object
 /// </summary>
 /// <param name="digestionParams"></param>
 /// <param name="allKnownFixedModifications"></param>
 /// <param name="variableModifications"></param>
 public ProteinDigestion(IDigestionParams digestionParams, IEnumerable <ModificationWithMass> allKnownFixedModifications, List <ModificationWithMass> variableModifications)
 {
     DigestionParams             = digestionParams;
     Protease                    = digestionParams.Protease;
     MaximumMissedCleavages      = digestionParams.MaxMissedCleavages;
     InitiatorMethionineBehavior = digestionParams.InitiatorMethionineBehavior;
     MinPeptidesLength           = digestionParams.MinPeptideLength;
     MaxPeptidesLength           = digestionParams.MaxPeptideLength;
     AllKnownFixedModifications  = allKnownFixedModifications;
     VariableModifications       = variableModifications;
 }
        /// <summary>
        /// Gets peptides for digestion of a protein
        /// </summary>
        /// <param name="protein"></param>
        /// <param name="digestionParams"></param>
        /// <param name="allKnownFixedModifications"></param>
        /// <param name="variableModifications"></param>
        /// <returns></returns>
        public static IEnumerable <PeptideWithSetModifications> Digest(this Protein protein, IDigestionParams digestionParams, IEnumerable <ModificationWithMass> allKnownFixedModifications, List <ModificationWithMass> variableModifications)
        {
            ProteinDigestion digestion = new ProteinDigestion(digestionParams, allKnownFixedModifications, variableModifications);

            return(digestionParams.SemiProteaseDigestion ? digestion.SemiSpecificDigestion(protein) : digestion.Digestion(protein));
        }
Beispiel #3
0
        /// <summary>
        /// Gets the peptides for a specific protein interval
        /// </summary>
        /// <param name="interval"></param>
        /// <param name="allKnownFixedModifications"></param>
        /// <param name="digestionParams"></param>
        /// <param name="variableModifications"></param>
        /// <returns></returns>
        internal IEnumerable <PeptideWithSetModifications> GetModifiedPeptides(IEnumerable <ModificationWithMass> allKnownFixedModifications,
                                                                               IDigestionParams digestionParams, List <ModificationWithMass> variableModifications)
        {
            int peptideLength = OneBasedEndResidueInProtein - OneBasedStartResidueInProtein + 1;
            int maximumVariableModificationIsoforms = digestionParams.MaxModificationIsoforms;
            int maxModsForPeptide = digestionParams.MaxModsForPeptide;
            var twoBasedPossibleVariableAndLocalizeableModifications = new Dictionary <int, List <ModificationWithMass> >(peptideLength + 4);

            var pepNTermVariableMods = new List <ModificationWithMass>();

            twoBasedPossibleVariableAndLocalizeableModifications.Add(1, pepNTermVariableMods);

            var pepCTermVariableMods = new List <ModificationWithMass>();

            twoBasedPossibleVariableAndLocalizeableModifications.Add(peptideLength + 2, pepCTermVariableMods);

            foreach (ModificationWithMass variableModification in variableModifications)
            {
                // Check if can be a n-term mod
                if (CanBeNTerminalMod(variableModification, peptideLength))
                {
                    pepNTermVariableMods.Add(variableModification);
                }

                for (int r = 0; r < peptideLength; r++)
                {
                    if (Gptmd.GptmdEngine.ModFits(variableModification, Protein, r + 1, peptideLength, OneBasedStartResidueInProtein + r) &&
                        variableModification.terminusLocalization == TerminusLocalization.Any)
                    {
                        if (!twoBasedPossibleVariableAndLocalizeableModifications.TryGetValue(r + 2, out List <ModificationWithMass> residueVariableMods))
                        {
                            residueVariableMods = new List <ModificationWithMass> {
                                variableModification
                            };
                            twoBasedPossibleVariableAndLocalizeableModifications.Add(r + 2, residueVariableMods);
                        }
                        else
                        {
                            residueVariableMods.Add(variableModification);
                        }
                    }
                }
                // Check if can be a c-term mod
                if (CanBeCTerminalMod(variableModification, peptideLength))
                {
                    pepCTermVariableMods.Add(variableModification);
                }
            }

            // LOCALIZED MODS
            foreach (var kvp in Protein.OneBasedPossibleLocalizedModifications)
            {
                bool inBounds = kvp.Key >= OneBasedStartResidueInProtein && kvp.Key <= OneBasedEndResidueInProtein;
                if (!inBounds)
                {
                    continue;
                }

                int locInPeptide = kvp.Key - OneBasedStartResidueInProtein + 1;
                foreach (Modification modWithMass in kvp.Value)
                {
                    if (modWithMass is ModificationWithMass variableModification)
                    {
                        // Check if can be a n-term mod
                        if (locInPeptide == 1 && CanBeNTerminalMod(variableModification, peptideLength) && !Protein.IsDecoy)
                        {
                            pepNTermVariableMods.Add(variableModification);
                        }

                        for (int r = 0; r < peptideLength; r++)
                        {
                            if (locInPeptide == r + 1 &&
                                (Protein.IsDecoy ||
                                 (Gptmd.GptmdEngine.ModFits(variableModification, Protein, r + 1, peptideLength, OneBasedStartResidueInProtein + r) &&
                                  variableModification.terminusLocalization == TerminusLocalization.Any)))
                            {
                                if (!twoBasedPossibleVariableAndLocalizeableModifications.TryGetValue(r + 2, out List <ModificationWithMass> residueVariableMods))
                                {
                                    residueVariableMods = new List <ModificationWithMass> {
                                        variableModification
                                    };
                                    twoBasedPossibleVariableAndLocalizeableModifications.Add(r + 2, residueVariableMods);
                                }
                                else
                                {
                                    residueVariableMods.Add(variableModification);
                                }
                            }
                        }
                        // Check if can be a c-term mod
                        if (locInPeptide == peptideLength && CanBeCTerminalMod(variableModification, peptideLength) && !Protein.IsDecoy)
                        {
                            pepCTermVariableMods.Add(variableModification);
                        }
                    }
                }
            }

            int variable_modification_isoforms = 0;

            foreach (Dictionary <int, ModificationWithMass> kvp in GetVariableModificationPatterns(twoBasedPossibleVariableAndLocalizeableModifications, maxModsForPeptide, peptideLength))
            {
                int numFixedMods = 0;
                foreach (var ok in GetFixedModsOneIsNterminus(peptideLength, allKnownFixedModifications))
                {
                    if (!kvp.ContainsKey(ok.Key))
                    {
                        numFixedMods++;
                        kvp.Add(ok.Key, ok.Value);
                    }
                }
                yield return(new PeptideWithSetModifications(Protein, OneBasedStartResidueInProtein, OneBasedEndResidueInProtein,
                                                             PeptideDescription, MissedCleavages, kvp, numFixedMods));

                variable_modification_isoforms++;
                if (variable_modification_isoforms == maximumVariableModificationIsoforms)
                {
                    yield break;
                }
            }
        }