public bool HasPrecursorCalc(IsotopeLabelType labelType, ExplicitMods mods) { if (labelType.IsLight) return true; return TryGetPrecursorCalc(labelType, mods) != null; }
public double[] GetRetentionTimes(MsDataFileUri filePath, string peptideSequence, ExplicitMods explicitMods, RetentionTimeAlignmentIndex alignmentIndex = null) { string basename = filePath.GetFileNameWithoutExtension(); var source = DocumentRetentionTimes.RetentionTimeSources.Find(basename); if (source == null) { return new double[0]; } var library = PeptideSettings.Libraries.GetLibrary(source.Library); if (library == null) { return new double[0]; } var modifiedSequences = GetTypedSequences(peptideSequence, explicitMods) .Select(typedSequence => typedSequence.ModifiedSequence); int? index = (alignmentIndex != null ? alignmentIndex.FileIndex : null); var times = library.GetRetentionTimesWithSequences(source.Name, modifiedSequences, ref index).ToArray(); if (alignmentIndex != null) alignmentIndex.FileIndex = index; return times; }
public void OkDialog() { var peptide = NodePeptide.Peptide; var explicitModsCurrent = NodePeptide.ExplicitMods; var modsDoc = DocSettings.PeptideSettings.Modifications; var implicitMods = new ExplicitMods(NodePeptide, modsDoc.StaticModifications, Settings.Default.StaticModList, modsDoc.GetHeavyModifications(), Settings.Default.HeavyModList); // Get static modifications from the dialog, and check for equality with // the document implicit modifications. TypedExplicitModifications staticTypedMods = null; bool isVariableStaticMods = false; var staticMods = GetExplicitMods(_listComboStatic, Settings.Default.StaticModList); if (ArrayUtil.EqualsDeep(staticMods, implicitMods.StaticModifications)) { if (!NodePeptide.HasVariableMods) staticMods = null; // Use implicit modifications else { staticMods = explicitModsCurrent.StaticModifications; isVariableStaticMods = true; } } else if (explicitModsCurrent != null && ArrayUtil.EqualsDeep(staticMods, explicitModsCurrent.StaticModifications)) { staticMods = explicitModsCurrent.StaticModifications; } if (staticMods != null) { staticTypedMods = new TypedExplicitModifications(peptide, IsotopeLabelType.light, staticMods); } var listHeavyTypedMods = new List<TypedExplicitModifications>(); for (int i = 0; i < _listLabelTypeHeavy.Count; i++) { var labelType = _listLabelTypeHeavy[i]; var heavyMods = GetExplicitMods(_listListComboHeavy[i], Settings.Default.HeavyModList); if (ArrayUtil.EqualsDeep(heavyMods, implicitMods.GetModifications(labelType))) continue; var heavyTypedMods = new TypedExplicitModifications(peptide, labelType, heavyMods); listHeavyTypedMods.Add(heavyTypedMods.AddModMasses(staticTypedMods)); } ExplicitMods explicitMods = null; if (staticMods != null || listHeavyTypedMods.Count > 0) explicitMods = new ExplicitMods(peptide, staticMods, listHeavyTypedMods, isVariableStaticMods); Helpers.AssignIfEquals(ref explicitMods, explicitModsCurrent); ExplicitMods = explicitMods; DialogResult = DialogResult.OK; Close(); }
public double GetPrecursorMass(IsotopeLabelType labelType, string seq, ExplicitMods mods) { return GetPrecursorCalc(labelType, mods).GetPrecursorMass(seq); }
public RelativeRT GetRelativeRT(IsotopeLabelType labelType, string seq, ExplicitMods mods) { if (labelType.IsLight) return RelativeRT.Matching; // Default is matching RelativeRT relativeRT = RelativeRT.Matching; // One unkown modification makes everything unknown // One preceding modification with no unknowns make relative RT preceding // Overlapping overrides matching if (mods != null && mods.IsModified(labelType)) { foreach (var mod in mods.GetModifications(labelType)) { if (mod.Modification.RelativeRT == RelativeRT.Unknown) return RelativeRT.Unknown; if (mod.Modification.RelativeRT == RelativeRT.Preceding) relativeRT = RelativeRT.Preceding; else if (mod.Modification.RelativeRT == RelativeRT.Overlapping && relativeRT == RelativeRT.Matching) relativeRT = RelativeRT.Overlapping; } } else { foreach (var mod in PeptideSettings.Modifications.GetModifications(labelType)) { if (!mod.IsMod(seq)) continue; if (mod.RelativeRT == RelativeRT.Unknown) return RelativeRT.Unknown; if (mod.RelativeRT == RelativeRT.Preceding) relativeRT = RelativeRT.Preceding; else if (mod.RelativeRT == RelativeRT.Overlapping && relativeRT == RelativeRT.Matching) relativeRT = RelativeRT.Overlapping; } } return relativeRT; }
public IFragmentMassCalc GetFragmentCalc(IsotopeLabelType labelType, ExplicitMods mods) { var massCalcBase = GetBaseCalc(labelType, mods, _fragmentMassCalcs); if (massCalcBase != null) { // If this type is not explicitly modified, then it must be // heavy with explicit light modifications. if (!mods.IsModified(labelType)) labelType = IsotopeLabelType.light; if (!labelType.IsLight && !mods.HasModifications(labelType)) return null; return new ExplicitSequenceMassCalc(mods, massCalcBase, labelType); } return GetMassCalc(labelType, _fragmentMassCalcs); }
public string GetModifiedSequence(string seq, IsotopeLabelType labelType, ExplicitMods mods, SequenceModFormatType format = SequenceModFormatType.mass_diff, bool useExplicitModsOnly = false) { return GetPrecursorCalc(labelType, mods).GetModifiedSequence(seq, format, useExplicitModsOnly); }
private bool Accept(SrmSettings settings, Peptide peptide, ExplicitMods mods, IList<int> precursorCharges, PeptideFilterType filterType, out bool allowVariableMods) { // Assume variable modifications are not allowed until proven otherwise allowVariableMods = false; // Only filter user specified peptides based on the heuristic // filter when explicitly requested. bool useFilter = filterType == PeptideFilterType.full; if (filterType == PeptideFilterType.fasta) useFilter = peptide.Begin.HasValue; var libraries = PeptideSettings.Libraries; if (!libraries.HasLibraries || libraries.Pick == PeptidePick.filter) { if (!useFilter) { allowVariableMods = true; return true; } return PeptideSettings.Filter.Accept(settings, peptide, mods, out allowVariableMods); } // Check if the peptide is in the library for one of the // acceptable precursor charges. bool inLibrary = false; // If the libraries are not fully loaded, then act like nothing // could be found in the libraries. This will be corrected when // the libraries are loaded. if (libraries.IsLoaded && // Only check the library, if this is a custom ion or a peptide that already has // a variable modification, or the library contains some form of the peptide. // This is a performance improvement over checking every variable modification // of a peptide when it is not even in the library. (peptide.IsCustomIon || (mods != null && mods.IsVariableStaticMods) || LibrariesContainAny(peptide.Sequence))) { // Only allow variable modifications, if the peptide has no modifications // or already checking variable modifications, and there is reason to check // the library. Failing to do this check profiled as a performance bottleneck. allowVariableMods = mods == null || mods.IsVariableStaticMods; inLibrary = LibrariesContainMeasurablePeptide(peptide, precursorCharges, mods); } switch (libraries.Pick) { case PeptidePick.library: return inLibrary; case PeptidePick.both: return inLibrary && (!useFilter || PeptideSettings.Filter.Accept(settings, peptide, mods, out allowVariableMods)); default: return inLibrary || (!useFilter || PeptideSettings.Filter.Accept(settings, peptide, mods, out allowVariableMods)); } }
private IEnumerable<IsotopeLabelType> GetHeavyLabelTypes(ExplicitMods mods) { foreach (var typedMods in PeptideSettings.Modifications.GetHeavyModifications()) { IsotopeLabelType labelType = typedMods.LabelType; if (HasPrecursorCalc(labelType, mods)) yield return labelType; } }
public bool TryLoadSpectrum(string sequence, int charge, ExplicitMods mods, out IsotopeLabelType type, out SpectrumPeaksInfo spectrum) { var libraries = PeptideSettings.Libraries; foreach (var typedSequence in GetTypedSequences(sequence, mods)) { var key = new LibKey(typedSequence.ModifiedSequence, charge); if (libraries.TryLoadSpectrum(key, out spectrum)) { type = typedSequence.LabelType; return true; } } type = IsotopeLabelType.light; spectrum = null; return false; }
private static SequenceMassCalc GetBaseCalc(IsotopeLabelType labelType, ExplicitMods mods, IList<TypedMassCalc> massCalcs) { if (mods == null) return null; var calcLightImplicit = massCalcs[0].MassCalc; // If the light type is not modified if (!mods.IsModified(IsotopeLabelType.light)) { // If requesting the light calculator or an unmodified heavy, // then no explicit calculator is required. if (labelType.IsLight || !mods.IsModified(labelType)) return null; // Otherwise, use its calculator as the base for a heavy type // to make sure the implicit light modifications are included. return calcLightImplicit; } // If the type requested is not modified, it must be a heavy type // with the light type modified. In this case, return the heavy // calculator as the base, to which the light explicit modifications // may be applied to get modified masses. if (!mods.IsModified(labelType)) return GetMassCalc(labelType, massCalcs); // If the light modifications are variable, and this is a type for // which explicit modifications exist (including the light type itself), // then return the light calculator as base. if (mods.IsVariableStaticMods) return calcLightImplicit; // If both light and this type are modified, then us a base calculator // that contains no modifications at all. return (calcLightImplicit.MassType == MassType.Monoisotopic ? MonoisotopicMassCalc : AverageMassCalc); }
public bool TryGetRetentionTimes(string sequence, int charge, ExplicitMods mods, MsDataFileUri filePath, out IsotopeLabelType type, out double[] retentionTimes) { var libraries = PeptideSettings.Libraries; foreach (var typedSequence in GetTypedSequences(sequence, mods)) { var key = new LibKey(typedSequence.ModifiedSequence, charge); if (libraries.TryGetRetentionTimes(key, filePath, out retentionTimes)) { type = typedSequence.LabelType; return true; } } type = IsotopeLabelType.light; retentionTimes = null; return false; }
public bool TryGetLibInfo(string sequence, int charge, ExplicitMods mods, out IsotopeLabelType type, out SpectrumHeaderInfo libInfo) { if (sequence == null) { type = null; libInfo = null; return false; } var libraries = PeptideSettings.Libraries; foreach (var typedSequence in GetTypedSequences(sequence, mods)) { var key = new LibKey(typedSequence.ModifiedSequence, charge); if (libraries.TryGetLibInfo(key, out libInfo)) { type = typedSequence.LabelType; return true; } } type = IsotopeLabelType.light; libInfo = null; return false; }
public bool LibrariesContainMeasurablePeptide(Peptide peptide, IList<int> precursorCharges, ExplicitMods mods) { if (LibrariesContainMeasurablePeptide(peptide, IsotopeLabelType.light, precursorCharges, mods)) return true; // If light version not found, try heavy foreach (var labelType in GetHeavyLabelTypes(mods)) { if (LibrariesContainMeasurablePeptide(peptide, labelType, precursorCharges, mods)) return true; } return false; }
public double[] GetAllRetentionTimes(MsDataFileUri filePath, string peptideSequence, ExplicitMods explicitMods) { var times = new List<double>(); times.AddRange(GetRetentionTimes(filePath, peptideSequence, explicitMods)); times.AddRange(GetAlignedRetentionTimes(filePath, peptideSequence, explicitMods)); return times.ToArray(); }
private IEnumerable<TypedSequence> GetTypedSequences(string sequence, ExplicitMods mods) { var labelType = IsotopeLabelType.light; string modifiedSequence = GetModifiedSequence(sequence, labelType, mods); yield return new TypedSequence(modifiedSequence, labelType); foreach (var labelTypeHeavy in GetHeavyLabelTypes(mods)) { modifiedSequence = GetModifiedSequence(sequence, labelTypeHeavy, mods); yield return new TypedSequence(modifiedSequence, labelTypeHeavy); } }
/// <summary> /// Loads a list of all non-redundant spectra found in all loaded libraries /// matching the criteria passed in. /// </summary> /// <param name="sequence"> The sequence to match. </param> /// <param name="charge"> The charge to match. </param> /// <param name="mods"> The modifications to match. </param> /// <returns> Returns a list of the matching spectra. </returns> public IEnumerable<SpectrumInfo> GetBestSpectra(string sequence, int charge, ExplicitMods mods) { var libraries = PeptideSettings.Libraries; return from typedSequence in GetTypedSequences(sequence, mods) let key = new LibKey(typedSequence.ModifiedSequence, charge) from spectrumInfo in libraries.GetSpectra(key, typedSequence.LabelType, true) select spectrumInfo; }
private bool LibrariesContainMeasurablePeptide(Peptide peptide, IsotopeLabelType labelType, IEnumerable<int> precursorCharges, ExplicitMods mods) { string sequenceMod = GetModifiedSequence(peptide.Sequence, labelType, mods); foreach (int charge in precursorCharges) { if (LibrariesContain(sequenceMod, charge)) { // Make sure the peptide for the found spectrum is measurable on // the current instrument. double precursorMass = GetPrecursorMass(labelType, peptide.Sequence, mods); if (IsMeasurable(precursorMass, charge)) return true; } } return false; }
public double GetFragmentMass(IsotopeLabelType labelType, ExplicitMods mods, Transition transition, IsotopeDistInfo isotopeDist) { // Return the singly protonated mass of the peptide fragment, or custom ion mass before electron removal IFragmentMassCalc calc = GetFragmentCalc(labelType, mods); if (calc == null && transition.IsCustom()) { // Small molecules provide their own ion formula, just use the standard calculator calc = GetDefaultFragmentCalc(); } if (calc == null) { Assume.Fail(string.Format("Unable to locate fragment calculator for isotope label type {0} and mods {1}", // Not L10N labelType == null ? "(null)" : labelType.ToString(), // Not L10N mods == null ? "(null)" : mods.ToString())); // Not L10N return 0; // Keep resharper happy } return calc.GetFragmentMass(transition, isotopeDist); }
public bool Accept(SrmSettings settings, Peptide peptide, ExplicitMods explicitMods, out bool allowVariableMods) { return Accept(settings, peptide, explicitMods, TransitionSettings.Filter.PrecursorCharges, PeptideFilterType.fasta, out allowVariableMods); }
public IPrecursorMassCalc GetPrecursorCalc(IsotopeLabelType labelType, ExplicitMods mods) { var precursorCalc = TryGetPrecursorCalc(labelType, mods); if (precursorCalc == null) { // Try to track down this exception: // https://skyline.gs.washington.edu/labkey/announcements/home/issues/exceptions/thread.view?entityId=217d79c8-9a84-1032-ae5f-da2025829168&_anchor=19667#row:19667 throw new InvalidDataException( String.Format("unable to locate precursor calculator for isotope label type {0} and mods {1}", // Not L10N labelType == null ? "(null)" : labelType.ToString(), // Not L10N mods == null ? "(null)" : mods.ToString())); // Not L10N } return precursorCalc; }
/// <summary> /// This version of Accept is used to select transition groups after the peptide /// itself has already been screened. For this reason, it only applies library /// filtering. /// </summary> public bool Accept(SrmSettings settings, Peptide peptide, ExplicitMods mods, int charge) { bool allowVariableMods; return Accept(settings, peptide, mods, new[] { charge }, PeptideFilterType.library, out allowVariableMods); }
/// <summary> /// Loads a list of all the spectra found in all loaded libraries /// matching the criteria passed in. /// </summary> /// <param name="sequence"> The sequence to match. </param> /// <param name="charge"> The charge to match. </param> /// <param name="labelType">The primary label type to match</param> /// <param name="mods"> The modifications to match. </param> /// <returns> Returns a list of the matching spectra. </returns> public IEnumerable<SpectrumInfo> GetRedundantSpectra(string sequence, int charge, IsotopeLabelType labelType, ExplicitMods mods) { string sequenceMod = GetModifiedSequence(sequence, labelType, mods); return PeptideSettings.Libraries.GetSpectra(new LibKey(sequenceMod, charge), labelType, false); }
public double[] GetAlignedRetentionTimes(MsDataFileUri filePath, string peptideSequence, ExplicitMods explicitMods) { string basename = filePath.GetFileNameWithoutExtension(); var fileAlignments = DocumentRetentionTimes.FileAlignments.Find(basename); return GetAlignedRetentionTimes(new RetentionTimeAlignmentIndices(fileAlignments), peptideSequence, explicitMods); }
public double[] GetRetentionTimes(string filePath, string peptideSequence, ExplicitMods explicitMods, RetentionTimeAlignmentIndex alignmentIndex = null) { return GetRetentionTimes(MsDataFileUri.Parse(filePath), peptideSequence, explicitMods, alignmentIndex); }
public double[] GetAlignedRetentionTimes(RetentionTimeAlignmentIndices alignmentIndices, string peptideSequence, ExplicitMods explicitMods) { var times = new List<double>(); if (alignmentIndices != null) { foreach (var alignmentIndex in alignmentIndices) { var unalignedTimes = GetRetentionTimes(MsDataFileUri.Parse(alignmentIndex.Alignment.Name), peptideSequence, explicitMods, alignmentIndex); foreach (var unalignedTime in unalignedTimes) { var alignedTime = alignmentIndex.Alignment.RegressionLine.GetY(unalignedTime); times.Add(alignedTime); } } } return times.ToArray(); }
/// <summary> /// Returns the times at which a peptide was found in a particular file. /// </summary> public double[] GetRetentionTimes(LibraryRetentionTimes retentionTimes, string sequence, ExplicitMods mods) { return (from typedSequence in GetTypedSequences(sequence, mods) from time in retentionTimes.GetRetentionTimes(typedSequence.ModifiedSequence) select time) .ToArray(); }
public double[] GetAllRetentionTimes(string filePath, string peptideSequence, ExplicitMods explicitMods) { return GetAllRetentionTimes(MsDataFileUri.Parse(filePath), peptideSequence, explicitMods); }
public void ResetMods() { // CONSIDER: This means once a peptide with variable modifications is explicitly // modified, it is then treated the same as an unmodified peptide for // future resets. var explicitModsOrig = NodePeptide.ExplicitMods; if (!NodePeptide.HasVariableMods) ExplicitMods = null; else if (!explicitModsOrig.HasHeavyModifications) ExplicitMods = explicitModsOrig; else { // Construct a new explicit mods with only the variable modifications ExplicitMods = new ExplicitMods(NodePeptide.Peptide, explicitModsOrig.StaticModifications, new TypedExplicitModifications[0], true); } var modifications = DocSettings.PeptideSettings.Modifications; for (int i = 0; i < _listComboStatic.Count; i++) { UpdateComboItems(_listComboStatic[i], StaticList, ExplicitMods != null ? ExplicitMods.StaticModifications : null, modifications.StaticModifications, i, ExplicitMods != null && ExplicitMods.IsVariableStaticMods, true); } for (int i = 0; i < _listLabelTypeHeavy.Count; i++) { var labelType = _listLabelTypeHeavy[i]; var listComboHeavy = _listListComboHeavy[i]; for (int j = 0; j < listComboHeavy.Count; j++) { UpdateComboItems(listComboHeavy[j], HeavyList, null, modifications.GetModifications(labelType), j, false, true); } } }
public double[] GetUnalignedRetentionTimes(string peptideSequence, ExplicitMods explicitMods) { var times = new List<double>(); var modifiedSequences = GetTypedSequences(peptideSequence, explicitMods) .Select(typedSequence => typedSequence.ModifiedSequence).ToArray(); foreach (var library in PeptideSettings.Libraries.Libraries) { if (null == library) { continue; } foreach (var source in library.ListRetentionTimeSources()) { int? index = null; times.AddRange(library.GetRetentionTimesWithSequences(source.Name, modifiedSequences, ref index)); } } return times.ToArray(); }