public static Target FromSerializableString(string val) { if (!val.StartsWith(@"#")) { return(new Target(val)); } return(new Target(CustomMolecule.FromSerializableString(val))); }
public new static CustomIon FromTSV(string val) { var lastTab = val.LastIndexOf(TextUtil.SEPARATOR_TSV_STR, StringComparison.Ordinal); var adduct = Adduct.FromStringAssumeChargeOnly(val.Substring(lastTab + 1)); var mol = CustomMolecule.FromTSV(val.Substring(0, lastTab)); if (adduct.IsEmpty && mol.IsEmpty) { return(EMPTY); } return(new CustomIon(mol, adduct)); }
public static bool Equivalent(Transition t, Transition obj) { if (ReferenceEquals(t, obj)) { return(true); } return(Equals(obj.IonType, t.IonType) && obj.CleavageOffset == t.CleavageOffset && obj.Charge == t.Charge && obj.MassIndex == t.MassIndex && CustomMolecule.Equivalent(obj.CustomIon, t.CustomIon) && // Looks at unlabeled formula or name only (obj.DecoyMassShift.Equals(t.DecoyMassShift) || // Deal with strange case of mProphet golden standard data set - only a concern for peptides, not small molecules (obj.DecoyMassShift.HasValue && t.DecoyMassShift.HasValue && (obj.Group.LabelType.IsLight && obj.DecoyMassShift == 0 && !t.Group.LabelType.IsLight && t.DecoyMassShift != 0) || (!obj.Group.LabelType.IsLight && obj.DecoyMassShift != 0 && t.Group.LabelType.IsLight && t.DecoyMassShift == 0)))); }
private void Validate() { if (IsCustomMolecule) { Assume.IsNull(_fastaSequence); Assume.IsNull(Sequence); CustomMolecule.Validate(); } else if (_fastaSequence == null) { if (Begin.HasValue || End.HasValue) { throw new InvalidDataException(Resources.Peptide_Validate_Peptides_without_a_protein_sequence_do_not_support_the_start_and_end_properties); } // No FastaSequence checked the sequence, so check it here. FastaSequence.ValidateSequence(Target.Sequence); } else { // Otherwise, validate the peptide sequence against the group sequence if (!Begin.HasValue || !End.HasValue) { throw new InvalidDataException(Resources.Peptide_Validate_Peptides_from_protein_sequences_must_have_start_and_end_values); } if (0 > Begin.Value || End.Value > _fastaSequence.Sequence.Length) { throw new InvalidDataException(Resources.Peptide_Validate_Peptide_sequence_exceeds_the_bounds_of_the_protein_sequence); } var j = 0; for (var i = Begin.Value; i < End.Value;) { if (!Equals(Target.Sequence[j++], _fastaSequence.Sequence[i++])) { string sequenceCheck = _fastaSequence.Sequence.Substring(Begin.Value, End.Value - Begin.Value); throw new InvalidDataException( string.Format(Resources.Peptide_Validate_The_peptide_sequence__0__does_not_agree_with_the_protein_sequence__1__at__2__3__, Target, sequenceCheck, Begin.Value, End.Value)); } } } // CONSIDER: Validate missed cleavages some day? }
public Transition(TransitionGroup group, IonType type, int?offset, int?massIndex, Adduct adduct, int?decoyMassShift, CustomMolecule customMolecule = null) { _group = group; IonType = type; CleavageOffset = offset ?? 0; MassIndex = massIndex ?? 0; Adduct = adduct; DecoyMassShift = decoyMassShift; // Small molecule precursor transition should have same custom molecule as parent if (IsPrecursor(type) && group.IsCustomIon) { CustomIon = new CustomIon(group.CustomMolecule, adduct); } else if (customMolecule is CustomIon) { // As with reporter ions CustomIon = (CustomIon)customMolecule; Assume.IsTrue(Equals(adduct.AdductCharge, CustomIon.Adduct.AdductCharge)); Adduct = CustomIon.Adduct; // Ion mass is part of formula, so use charge only adduct } else if (customMolecule != null) { CustomIon = new CustomIon(customMolecule, adduct); } // Derived values if (!IsCustom(type, group)) { Peptide peptide = group.Peptide; Ordinal = OffsetToOrdinal(type, (int)offset, peptide.Length); AA = (IsNTerminal() ? peptide.Sequence[(int)offset] : peptide.Sequence[(int)offset + 1]); } else { // caller may have passed in offset = group.Peptide.Length - 1, which for custom ions gives -1 CleavageOffset = 0; } Validate(); }
public SmallMoleculeLibraryAttributes GetSmallMoleculeLibraryAttributes() { return(IsCustomMolecule ? CustomMolecule.GetSmallMoleculeLibraryAttributes() : SmallMoleculeLibraryAttributes.EMPTY); }
public Transition(TransitionGroup group, Adduct charge, int?massIndex, CustomMolecule customMolecule, IonType type = IonType.custom) : this(group, type, null, massIndex, charge, null, customMolecule) { }
/// <summary> /// Creates a precursor transition /// </summary> /// <param name="group">The <see cref="TransitionGroup"/> which the transition represents</param> /// <param name="massIndex">Isotope mass shift</param> /// <param name="productAdduct">Adduct on the transition</param> /// <param name="customMolecule">Non-null if this is a custom transition</param> public Transition(TransitionGroup group, int massIndex, Adduct productAdduct, CustomMolecule customMolecule = null) : this(group, IonType.precursor, group.Peptide.Length - 1, massIndex, productAdduct, null, customMolecule) { }
public Target(CustomMolecule molecule) { Molecule = molecule; }
public Target(SmallMoleculeLibraryAttributes molecule) { Molecule = new CustomMolecule(molecule); }
private TransitionDocNode CreateTransitionNode(int massIndex, TypedMass precursorMassH, TransitionIsotopeDistInfo isotopeDistInfo, TransitionLosses losses, IDictionary <double, LibraryRankedSpectrumInfo.RankedMI> transitionRanks, Adduct productAdduct, CustomMolecule customMolecule = null) { Transition transition = new Transition(this, massIndex, productAdduct, customMolecule); var quantInfo = TransitionDocNode.TransitionQuantInfo.GetLibTransitionQuantInfo(transition, losses, Transition.CalcMass(precursorMassH, losses), transitionRanks).ChangeIsotopeDistInfo(isotopeDistInfo); var transitionDocNode = new TransitionDocNode(transition, losses, precursorMassH, quantInfo, ExplicitTransitionValues.EMPTY); if (massIndex < 0) { transitionDocNode = transitionDocNode.ChangeQuantitative(false); } return(transitionDocNode); }
public Peptide(CustomMolecule customMolecule) { Target = new Target(customMolecule); Validate(); }
public Target(SmallMoleculeLibraryAttributes molecule) { Molecule = CustomMolecule.FromSmallMoleculeLibraryAttributes(molecule); }
public IEnumerable <TransitionDocNode> GetPrecursorTransitions(SrmSettings settings, ExplicitMods mods, IPrecursorMassCalc calcPredictPre, IFragmentMassCalc calcPredict, double precursorMz, IsotopeDistInfo isotopeDist, IList <IList <ExplicitLoss> > potentialLosses, IDictionary <double, LibraryRankedSpectrumInfo.RankedMI> transitionRanks, bool libraryFilter, bool useFilter) { var tranSettings = settings.TransitionSettings; var fullScan = tranSettings.FullScan; int minMz = tranSettings.Instrument.GetMinMz(precursorMz); int maxMz = tranSettings.Instrument.MaxMz; bool precursorMS1 = fullScan.IsEnabledMs; MassType massType = tranSettings.Prediction.FragmentMassType; MassType massTypeIon = precursorMS1 ? tranSettings.Prediction.PrecursorMassType : massType; var sequence = Peptide.Target; var ionTypes = IsProteomic ? tranSettings.Filter.PeptideIonTypes : tranSettings.Filter.SmallMoleculeIonTypes; bool precursorNoProducts = precursorMS1 && !fullScan.IsEnabledMsMs && ionTypes.Count == 1 && ionTypes[0] == IonType.precursor; var precursorMassPredict = precursorMS1 ? calcPredictPre.GetPrecursorMass(sequence) : calcPredict.GetPrecursorFragmentMass(sequence); foreach (var losses in CalcTransitionLosses(IonType.precursor, 0, massType, potentialLosses)) { double ionMz = IsProteomic ? SequenceMassCalc.GetMZ(Transition.CalcMass(precursorMassPredict, losses), PrecursorAdduct) : PrecursorAdduct.MzFromNeutralMass(CustomMolecule.GetMass(massTypeIon), massTypeIon); if (losses == null) { if (precursorMS1 && isotopeDist != null) { foreach (int i in fullScan.SelectMassIndices(isotopeDist, useFilter)) { var precursorMS1Mass = isotopeDist.GetMassI(i, DecoyMassShift); ionMz = SequenceMassCalc.GetMZ(precursorMS1Mass, PrecursorAdduct); if (minMz > ionMz || ionMz > maxMz) { continue; } var isotopeDistInfo = new TransitionIsotopeDistInfo( isotopeDist.GetRankI(i), isotopeDist.GetProportionI(i)); yield return(CreateTransitionNode(i, precursorMS1Mass, isotopeDistInfo, null, transitionRanks)); } continue; } } // If there was loss, it is possible (though not likely) that the ion m/z value // will now fall below the minimum measurable value for the instrument else if (minMz > ionMz) { continue; } // If filtering precursors from MS1 scans, then ranking in MS/MS does not apply bool precursorIsProduct = !precursorMS1 || losses != null; // Skip product ion precursors, if the should not be included if (useFilter && precursorIsProduct && precursorNoProducts) { continue; } if (!useFilter || !precursorIsProduct || !libraryFilter || IsMatched(transitionRanks, ionMz, IonType.precursor, PrecursorAdduct, losses)) { yield return(CreateTransitionNode(0, precursorMassPredict, null, losses, precursorIsProduct ? transitionRanks : null)); } } }
public PeptideDocNode GetModifiedNode(LibKey key, SrmSettings settings, SrmSettingsDiff diff) { var smallMoleculeKey = key.LibraryKey as MoleculeLibraryKey; var peptideKey = key.LibraryKey as PeptideLibraryKey; Peptide peptide; if (smallMoleculeKey != null) { peptide = new Peptide(CustomMolecule.FromSmallMoleculeLibraryAttributes(smallMoleculeKey.SmallMoleculeLibraryAttributes)); } else if (peptideKey != null) { peptide = new Peptide(null, peptideKey.UnmodifiedSequence, null, null, settings.PeptideSettings.Enzyme.CountCleavagePoints(peptideKey.UnmodifiedSequence)); } else { return(null); } // First try and create the match from the settings created to match the library explorer. Settings = HasMatches ? settings.ChangePeptideModifications(mods => MatcherPepMods) : settings; TransitionGroupDocNode nodeGroup; var nodePep = CreateDocNodeFromSettings(key, peptide, diff, out nodeGroup); if (nodePep != null) { if (diff == null) { nodePep = (PeptideDocNode)nodePep.ChangeAutoManageChildren(false); } else { // Keep only the matching transition group, so that modifications // will be highlighted differently for light and heavy forms. // Only performed when getting peptides for display in the explorer. nodePep = (PeptideDocNode)nodePep.ChangeChildrenChecked( new DocNode[] { nodeGroup }); } return(nodePep); } else if (Matches == null) { return(null); } bool hasHeavy; // Create explicit mods from the found matches. nodePep = CreateDocNodeFromMatches(new PeptideDocNode(peptide), EnumerateSequenceInfos(key.LibraryKey as PeptideLibraryKey, true), false, out hasHeavy); if (nodePep == null) { return(null); } // Call change settings with the matched modification settings to enumerate the children. nodePep = nodePep.ChangeSettings(settings.ChangePeptideModifications(mods => !HasMatches ? settings.PeptideSettings.Modifications : MatcherPepMods), diff ?? SrmSettingsDiff.ALL); if (nodePep.Children.Count == 0) { return(null); } // Select the correct child, only for use with the library explorer. if (diff != null && nodePep.Children.Count > 1) { nodePep = (PeptideDocNode) nodePep.ChangeChildrenChecked(new List <DocNode> { nodePep.Children[hasHeavy ? 1 : 0] }); } if (diff == null) { nodePep = (PeptideDocNode)nodePep.ChangeAutoManageChildren(false); } return(nodePep); }
private TransitionDocNode CreateTransitionNode(IonType type, int cleavageOffset, Adduct charge, TypedMass massH, TransitionLosses losses, IDictionary <double, LibraryRankedSpectrumInfo.RankedMI> transitionRanks, CustomMolecule customMolecule = null) { Transition transition = new Transition(this, type, cleavageOffset, 0, charge, null, customMolecule); var info = TransitionDocNode.TransitionQuantInfo.GetLibTransitionQuantInfo(transition, losses, Transition.CalcMass(massH, losses), transitionRanks); return(new TransitionDocNode(transition, losses, massH, info)); }
private TransitionDocNode CreateTransitionNode(int massIndex, TypedMass precursorMassH, TransitionIsotopeDistInfo isotopeDistInfo, TransitionLosses losses, IDictionary <double, LibraryRankedSpectrumInfo.RankedMI> transitionRanks, CustomMolecule customMolecule = null) { Transition transition = new Transition(this, massIndex, customMolecule); var quantInfo = TransitionDocNode.TransitionQuantInfo.GetLibTransitionQuantInfo(transition, losses, Transition.CalcMass(precursorMassH, losses), transitionRanks).ChangeIsotopeDistInfo(isotopeDistInfo); return(new TransitionDocNode(transition, losses, precursorMassH, quantInfo)); }
public CustomIon(CustomMolecule mol, Adduct adduct) : this(mol.Formula, adduct, mol.MonoisotopicMass, mol.AverageMass, mol.Name) { }
public static TransitionDocNode FromTransitionProto(AnnotationScrubber scrubber, SrmSettings settings, TransitionGroup group, ExplicitMods mods, IsotopeDistInfo isotopeDist, ExplicitTransitionValues pre422ExplicitTransitionValues, SkylineDocumentProto.Types.Transition transitionProto) { var stringPool = scrubber.StringPool; IonType ionType = DataValues.FromIonType(transitionProto.FragmentType); MeasuredIon measuredIon = null; if (transitionProto.MeasuredIonName != null) { measuredIon = settings.TransitionSettings.Filter.MeasuredIons.SingleOrDefault( i => i.Name.Equals(transitionProto.MeasuredIonName.Value)); if (measuredIon == null) { throw new InvalidDataException(string.Format(Resources.TransitionInfo_ReadXmlAttributes_The_reporter_ion__0__was_not_found_in_the_transition_filter_settings_, transitionProto.MeasuredIonName)); } ionType = IonType.custom; } bool isCustom = Transition.IsCustom(ionType, group); bool isPrecursor = Transition.IsPrecursor(ionType); CustomMolecule customIon = null; if (isCustom) { if (measuredIon != null) { customIon = measuredIon.SettingsCustomIon; } else if (isPrecursor) { customIon = group.CustomMolecule; } else { var formula = DataValues.FromOptional(transitionProto.Formula); var moleculeID = MoleculeAccessionNumbers.FromString(DataValues.FromOptional(transitionProto.MoleculeId)); // Tab separated list of InChiKey, CAS etc var monoMassH = DataValues.FromOptional(transitionProto.MonoMassH); var averageMassH = DataValues.FromOptional(transitionProto.AverageMassH); var monoMass = DataValues.FromOptional(transitionProto.MonoMass) ?? monoMassH; var averageMass = DataValues.FromOptional(transitionProto.AverageMass) ?? averageMassH; customIon = new CustomMolecule(formula, new TypedMass(monoMass.Value, monoMassH.HasValue ? MassType.MonoisotopicMassH : MassType.Monoisotopic), new TypedMass(averageMass.Value, averageMassH.HasValue ? MassType.AverageMassH : MassType.Average), DataValues.FromOptional(transitionProto.CustomIonName), moleculeID); } } Transition transition; var adductString = DataValues.FromOptional(transitionProto.Adduct); var adduct = string.IsNullOrEmpty(adductString) ? Adduct.FromChargeProtonated(transitionProto.Charge) : Adduct.FromStringAssumeChargeOnly(adductString); if (isCustom) { transition = new Transition(group, isPrecursor ? group.PrecursorAdduct :adduct, transitionProto.MassIndex, customIon, ionType); } else if (isPrecursor) { transition = new Transition(group, ionType, group.Peptide.Length - 1, transitionProto.MassIndex, group.PrecursorAdduct, DataValues.FromOptional(transitionProto.DecoyMassShift)); } else { int offset = Transition.OrdinalToOffset(ionType, transitionProto.FragmentOrdinal, group.Peptide.Length); transition = new Transition(group, ionType, offset, transitionProto.MassIndex, adduct, DataValues.FromOptional(transitionProto.DecoyMassShift)); } var losses = TransitionLosses.FromLossProtos(settings, transitionProto.Losses); var mass = settings.GetFragmentMass(group, mods, transition, isotopeDist); var isotopeDistInfo = GetIsotopeDistInfo(transition, losses, isotopeDist); if (group.DecoyMassShift.HasValue && transitionProto.DecoyMassShift == null) { throw new InvalidDataException(Resources.SrmDocument_ReadTransitionXml_All_transitions_of_decoy_precursors_must_have_a_decoy_mass_shift); } TransitionLibInfo libInfo = null; if (transitionProto.LibInfo != null) { libInfo = new TransitionLibInfo(transitionProto.LibInfo.Rank, transitionProto.LibInfo.Intensity); } var annotations = scrubber.ScrubAnnotations(Annotations.FromProtoAnnotations(transitionProto.Annotations), AnnotationDef.AnnotationTarget.transition); var results = TransitionChromInfo.FromProtoTransitionResults(scrubber, settings, transitionProto.Results); var explicitTransitionValues = pre422ExplicitTransitionValues ?? ExplicitTransitionValues.Create( DataValues.FromOptional(transitionProto.ExplicitCollisionEnergy), DataValues.FromOptional(transitionProto.ExplicitIonMobilityHighEnergyOffset), DataValues.FromOptional(transitionProto.ExplicitSLens), DataValues.FromOptional(transitionProto.ExplicitConeVoltage), DataValues.FromOptional(transitionProto.ExplicitDeclusteringPotential)); return(new TransitionDocNode(transition, annotations, losses, mass, new TransitionQuantInfo(isotopeDistInfo, libInfo, !transitionProto.NotQuantitative), explicitTransitionValues, results)); }