public static double CalcMonoisotopicMass(string sequence, PeptideModificationState varMod, Modification[] fixMod) { double result = AminoAcid.CalcMonoisotopicMass(sequence) + varMod.GetDeltaMass(); foreach (char c in sequence) { result += GetDeltaFixed(c, fixMod); } return(result); }
/// <summary> /// Indication of whether or not an ISequenceItem is in the alphabet. This is /// a simple lookup and will only match exactly with items of this alphabet. It /// will not compare items from other alphabets that match the same amino acid. /// </summary> public bool Contains(ISequenceItem item) { AminoAcid aa = item as AminoAcid; if (aa == null) { return(false); } return(values.Contains(aa)); }
// ReSharper disable MemberCanBeMadeStatic.Local private void comboAA_KeyPress(object sender, KeyPressEventArgs e) { // Force uppercase in this control. e.KeyChar = char.ToUpper(e.KeyChar); // Only allow amino acid characters space, comma and backspace // ReSharper disable once LocalizableElement if (!AminoAcid.IsAA(e.KeyChar) && " ,\b".IndexOf(e.KeyChar) == -1) { e.Handled = true; } }
public AminoAcid CreateAminoAcid() { var aminoAcid = new AminoAcid() { Name = "TestAminoAcid", Code = "Z" }; aminoAcid.Codons.Add(CreateCodon()); return(GetOrCreate(() => aminoAcid)); }
/// <summary> /// Initializes new instance of <see cref="FragmentViewModel" />. /// </summary> /// <param name="aminoAcid">The selected amino acid.</param> /// <param name="index">The index of this fragment within the greater sequence that it is part of.</param> /// <param name="dialogService">Dialog service for opening LCMSSpectator dialogs.</param> public FragmentViewModel(AminoAcid aminoAcid, int index = 0, IMainDialogService dialogService = null) { AminoAcid = aminoAcid; Index = index; SetModSymbol(aminoAcid as ModifiedAminoAcid); this.dialogService = dialogService ?? new MainDialogService(); SelectModificationCommand = ReactiveCommand.Create(SelectModificationImpl); // Update the modification symbol when the amino acid changes. this.WhenAnyValue(x => x.AminoAcid).Subscribe(aa => SetModSymbol(aa as ModifiedAminoAcid)); }
private void Validate() { if (string.IsNullOrEmpty(CleavageC) && string.IsNullOrEmpty(CleavageN)) { throw new InvalidDataException(Resources.Enzyme_Validate_Enzymes_must_have_at_least_one_cleavage_point); } var cleavageAll = String.Empty; if (string.IsNullOrEmpty(CleavageC)) { if (!string.IsNullOrEmpty(RestrictC)) { throw new InvalidDataException(Resources.Enzyme_Validate_Enzyme_must_have_C_terminal_cleavage_to_have_C_terminal_restrictions_); } CleavageC = RestrictC = null; _cleavageC = null; _restrictC = null; } else { AminoAcid.ValidateAAList(CleavageC); if (!string.IsNullOrEmpty(RestrictC)) { AminoAcid.ValidateAAList(RestrictC); } _cleavageC = CleavageC.ToCharArray(); _restrictC = RestrictC == null? null : RestrictC.ToCharArray(); cleavageAll = CleavageC; } if (string.IsNullOrEmpty(CleavageN)) { if (!string.IsNullOrEmpty(RestrictN)) { throw new InvalidDataException(Resources.Enzyme_Validate_Enzyme_must_have_N_terminal_cleavage_to_have_N_terminal_restrictions_); } CleavageN = RestrictN = null; _cleavageN = null; _restrictN = null; } else { AminoAcid.ValidateAAList(CleavageN); if (!string.IsNullOrEmpty(RestrictN)) { AminoAcid.ValidateAAList(RestrictN); } _cleavageN = CleavageN.ToCharArray(); _restrictN = RestrictN == null ? null : RestrictN.ToCharArray(); cleavageAll += CleavageN; } _cleavageAll = cleavageAll.ToCharArray(); }
private static IEnumerable <Composition> DefaultCompositionCalculator( Dictionary <char, double[]> possibleOffsets, AminoAcid aminoAcid) { if (aminoAcid == null) { return(possibleOffsets['*'].Select(off => new CompositionWithDeltaMass(off))); } var key = possibleOffsets.ContainsKey(aminoAcid.Residue) ? aminoAcid.Residue : '*'; return(possibleOffsets[key].Select(offset => new CompositionWithDeltaMass(offset) - aminoAcid.Composition)); }
/// <summary> /// Initializes a new instance of the <see cref="FlipScoringGraphEdge" /> /// with initialized data. /// </summary> /// <param name="prevNodeIndex">The source node index.</param> /// <param name="sinkNodeIndex">The sink node index.</param> /// <param name="weight">The edge weight.</param> /// <param name="label">The amino acid that that the edge corresponds to.</param> /// <param name="scorer">The FLIP scoring model.</param> public FlipScoringGraphEdge( int prevNodeIndex, int sinkNodeIndex, double weight, AminoAcid label, FlipScorer <DeconvolutedSpectrum> scorer) { this.PrevNodeIndex = prevNodeIndex; this.SinkNodeIndex = sinkNodeIndex; this.Weight = weight; this.Label = label; this.scorer = scorer; }
private Group TranslateCDKMonomer(IMonomer iMonomer) { // find type Type cdkType = iMonomer.GetType(); if (cdkType is AminoAcid) { AminoAcid amino = (AminoAcid)iMonomer; //AminoMonomer monomer = new AminoMonomer(); } return(null); }
/// <summary> /// Constructor /// </summary> /// <param name="aa"></param> /// <param name="modification"></param> public ModifiedAminoAcid(AminoAcid aa, Modification modification) : base(aa.Residue, aa.Name + "+" + modification.Name, aa.Composition + modification.Composition) { var modAa = aa as ModifiedAminoAcid; if (modAa == null) { _modification = modification; // aa is not modified } else // aa is already modified { _modification = Modification.RegisterAndGetModification(modAa.Modification.Name + "+" + modification.Name, Composition); } }
/// <summary>Initializes a new instance of the <see cref="GraphXSequenceGraph"/> class.</summary> /// <param name="aminoAcidSet">The amino acid set.</param> /// <param name="nterm">The n-terminal residue of the sequence.</param> /// <param name="sequence">The sequence.</param> /// <param name="cterm">The c-terminal residue of the sequence.</param> /// <param name="mods">The search modification to apply to the sequence.</param> protected GraphXSequenceGraph(AminoAcidSet aminoAcidSet, AminoAcid nterm, string sequence, AminoAcid cterm, IEnumerable <SearchModification> mods) : base(aminoAcidSet, nterm, sequence, cterm) { var modList = mods.ToList(); var ntermMods = (from m in modList where (m.IsFixedModification && (m.Location == SequenceLocation.ProteinNTerm || m.Location == SequenceLocation.PeptideNTerm)) select m).ToList(); var ctermMods = (from m in modList where (m.IsFixedModification && (m.Location == SequenceLocation.ProteinCTerm || m.Location == SequenceLocation.PeptideCTerm)) select m).ToList(); Modification ntermMod = null; foreach (var nmod in ntermMods) { ntermMod = nmod.Modification; if (nmod.TargetResidue == nterm.Residue) { break; } } Modification ctermMod = null; foreach (var cmod in ctermMods) { ctermMod = cmod.Modification; if (cmod.TargetResidue == cterm.Residue) { break; } } nterminal = null; cterminal = null; if (ntermMod != null) { nterminal = new ModifiedAminoAcid(new AminoAcid('(', "NTerm", Composition.Zero), ntermMod); } if (ctermMod != null) { cterminal = new ModifiedAminoAcid(new AminoAcid(')', "CTerm", Composition.Zero), ctermMod); } DataGraph = new DataGraph(); BuildGraph(); }
public override bool Equals(object obj) { if (obj == null) { return(false); } if (this == obj) { return(true); } AminoAcid other = obj as AminoAcid; return(other?.Letter == Letter); }
/// <summary> /// The original had support for a chargeIncrement variable, which /// I did not understand, but reviewing a calculate_pi program written by Jimmy Eng, /// I found that he used zero for this variable: /// http://sashimi.svn.sourceforge.net/viewvc/sashimi/trunk/trans_proteomic_pipeline/src/util/calculate_pi.cpp?revision=5807&view=markup /// The results of using zero are different from using 1, and they match up perfectly /// with this web-based pI calculator: /// http://expasy.org/tools/pi_tool.html /// I have left the chargeIncrement parameter for historical reasons, but suggest /// using the default, unless you understand this variable better than I do. /// </summary> /// <param name="seq">The peptide sequence for which the isoelectric point (pI) is desired</param> /// <param name="chargeIncrement">Meaning unknown</param> /// <returns>The calculated pI for the peptide</returns> public static double Calculate(string seq, int chargeIncrement = 0) { int[] comp = new int[26]; /* Amino acid composition of the protein */ foreach (char aa in seq) { comp[AminoAcid.ToIndex(aa)]++; } int ntermRes = AminoAcid.ToIndex(seq.First()); int ctermRes = AminoAcid.ToIndex(seq.Last()); double phMin = PH_MIN; double phMax = PH_MAX; int i; double phMid = 0; for (i = 0; i < MAXLOOP && (phMax - phMin) > EPSI; i++) { phMid = phMin + (phMax - phMin) / 2.0; double cter = Exp10(-PK[ctermRes, 0]) / (Exp10(-PK[ctermRes, 0]) + Exp10(-phMid)); double nter = Exp10(-phMid) / (Exp10(-PK[ntermRes, 1]) + Exp10(-phMid)); double carg = comp[R] * Exp10(-phMid) / (Exp10(-PK[R, 2]) + Exp10(-phMid)); double chis = comp[H] * Exp10(-phMid) / (Exp10(-PK[H, 2]) + Exp10(-phMid)); double clys = comp[K] * Exp10(-phMid) / (Exp10(-PK[K, 2]) + Exp10(-phMid)); double casp = comp[D] * Exp10(-PK[D, 2]) / (Exp10(-PK[D, 2]) + Exp10(-phMid)); double cglu = comp[E] * Exp10(-PK[E, 2]) / (Exp10(-PK[E, 2]) + Exp10(-phMid)); double ccys = comp[C] * Exp10(-PK[C, 2]) / (Exp10(-PK[C, 2]) + Exp10(-phMid)); double ctyr = comp[Y] * Exp10(-PK[Y, 2]) / (Exp10(-PK[Y, 2]) + Exp10(-phMid)); double charge = carg + clys + chis + nter + chargeIncrement - (casp + cglu + ctyr + ccys + cter); if (charge > 0.0) { phMin = phMid; } else { phMax = phMid; } } return(phMid); }
public static void ValidateSequence(string seq) { if (string.IsNullOrEmpty(seq)) { throw new InvalidDataException(Resources.FastaSequence_ValidateSequence_A_protein_sequence_may_not_be_empty); } for (int i = 0; i < seq.Length; i++) { char c = seq[i]; if (!AminoAcid.IsExAA(c) && c != '*' && c != '-') // Not L10N { throw new InvalidDataException(string.Format(Resources.FastaSequence_ValidateSequence_A_protein_sequence_may_not_contain_the_character__0__at__1__, seq[i], i)); } } }
/// <summary> /// Used to determine if a string contains a valid amino acid /// sequence. /// </summary> /// <param name="seq">The string to inspect.</param> /// <returns>True if the string is non-zero length and contains only amino acids.</returns> public static bool IsSequence(string seq) { if (seq.Length == 0) { return(false); } foreach (char c in seq) { if (!AminoAcid.IsAA(c)) { return(false); } } return(true); }
public override double GetFragmentScore(Composition prefixFragmentComposition, Composition suffixFragmentComposition, AminoAcid nTerminalResidue = null, AminoAcid cTerminalResidue = null) { var score = 0.0; var prefixHit = false; var suffixHit = false; foreach (var baseIonType in BaseIonTypes) { var fragmentComposition = baseIonType.IsPrefix ? prefixFragmentComposition + baseIonType.OffsetComposition : suffixFragmentComposition + baseIonType.OffsetComposition; var param = baseIonType.IsPrefix ? ScoreParam.Prefix : ScoreParam.Suffix; var massBinNum = _comparer.GetBinNumber(fragmentComposition.Mass); if (massBinNum >= 0 && massBinNum < _comparer.NumberOfBins) { if (_massBinToPeakMap.TryGetValue(massBinNum, out var existingPeak)) { var massErrorPpm = 1e6 * (Math.Abs(existingPeak.Mass - fragmentComposition.Mass) / fragmentComposition.Mass); score += param.Count; score += param.Intensity * Math.Min(existingPeak.Intensity / ReferencePeakIntensity, 1.0); // intensity-based scoring score += param.Dist * existingPeak.Dist; // Envelope distance-based scoring score += param.Corr * existingPeak.Corr; // Envelope correlation-based scoring score += param.MassError * massErrorPpm; // Envelope correlation-based scoring if (baseIonType.IsPrefix) { prefixHit = true; } else { suffixHit = true; } } } } if (prefixHit && suffixHit) { score += ScoreParam.ComplementaryIonCount; } return(score); }
public static AminoAcid[] CalcAllAas(SilacLabel[] labels1) { List <AminoAcid> result = new List <AminoAcid>(); for (int i = 0; i < labels1.Length; i++) { foreach (AminoAcid aa in AminoAcid.aminoAcids) { if (aa.Equals(AminoAcid.GetAminoAcidFromLabel(labels1[i]))) { result.Add(aa); break; } } } return(result.ToArray()); }
public static bool IsExSequence(string seq) { seq = StripModifications(seq); if (seq.Length == 0) { return(false); } foreach (char c in seq) { if (!AminoAcid.IsExAA(c)) { return(false); } } return(true); }
/// <summary> /// Handle a single umod:aa element and child nodes /// Called by ReadAminoAcids (xml hierarchy) /// </summary> /// <param name="reader">XmlReader that is only valid for the scope of the single umod:aa element</param> private static void ReadAminoAcid(XmlReader reader) { reader.MoveToContent(); // Move to the "aa" element string title = reader.GetAttribute("title"); string shortName = reader.GetAttribute("three_letter"); string fullName = reader.GetAttribute("full_name"); double monoMass = Convert.ToDouble(reader.GetAttribute("mono_mass")); double avgMass = Convert.ToDouble(reader.GetAttribute("avge_mass")); ChemFormula formula = ReadFormula(reader.ReadSubtree()); var amAcid = new AminoAcid(title, shortName, fullName, monoMass, avgMass, formula); AminoAcids.Add(title, amAcid); reader.Close(); }
/// <summary> /// Passes a valid RNA sequence with offset value and validates if /// Lookup(sequence) method is returning corresponding amino acid. /// </summary> /// <param name="sequenceNode">Sequence xml node.</param> /// <param name="offsetNode">Offset node with value.</param> /// <param name="aminoAcidNode">Expected amino acid value.</param> void ValidateCodonsTranslationWithOffset(string sequenceNode, string offsetNode, string aminoAcidNode) { // Get Node values from XML. string expectedSeq = _utilityObj._xmlUtil.GetTextValue(Constants.TranslationNode, sequenceNode); string expectedAminoAcid = _utilityObj._xmlUtil.GetTextValue(Constants.TranslationNode, aminoAcidNode); string expectedOffset = _utilityObj._xmlUtil.GetTextValue(Constants.CodonsNode, offsetNode); // Translate Rna to corresponding amino acid. ISequence codonsTranslation = new Sequence(Alphabets.RNA, expectedSeq); AminoAcid aminoAcid = Codons.Lookup(codonsTranslation, int.Parse(expectedOffset, null)); // Validate Codon Translation. Assert.AreEqual(expectedAminoAcid.ToString((IFormatProvider)null), aminoAcid.Symbol.ToString((IFormatProvider)null)); ApplicationLog.WriteLine( "Translation P1: Codon translation with offset validation is completed successfully."); }
//UPGRADE_NOTE: Final was removed from the declaration of '//logger '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'" //UPGRADE_NOTE: The initialization of '//logger' was moved to static method 'org.openscience.cdk.templates.AminoAcids'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1005'" //private static readonly LoggingTool //logger; /// <summary> Creates matrix with info about the bonds in the amino acids. /// 0 = bond id, 1 = atom1 in bond, 2 = atom2 in bond, 3 = bond order. /// </summary> /// <returns> info /// </returns> public static int[][] aaBondInfo() { if (aminoAcids == null) { createAAs(); } int[][] info = new int[153][]; for (int i = 0; i < 153; i++) { info[i] = new int[4]; } int counter = 0; int total = 0; for (int aa = 0; aa < aminoAcids.Length; aa++) { AminoAcid acid = aminoAcids[aa]; IBond[] bonds = acid.Bonds; //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.debug("#bonds for ", acid.getProperty(RESIDUE_NAME).ToString(), " = " + bonds.Length); total += bonds.Length; //logger.debug("total #bonds: ", total); for (int bCounter = 0; bCounter < bonds.Length; bCounter++) { info[counter][0] = counter; info[counter][1] = acid.getAtomNumber(bonds[bCounter].getAtomAt(0)); info[counter][2] = acid.getAtomNumber(bonds[bCounter].getAtomAt(1)); //UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'" info[counter][3] = (int)bonds[bCounter].Order; counter++; } } if (counter > 153) { //logger.error("Error while creating AA info! Bond count is too large: ", counter); return(null); } return(info); }
public void WriteModification(IMass modification, ModificationSites sites, bool fixedModification = true) { if (CurrentStage != Stage.SearchSummary) { throw new ArgumentException("You must be in the Search Summary stage to write modifications"); } foreach (ModificationSites singleSite in sites.GetActiveSites()) { double basemass = 0; if (singleSite >= ModificationSites.NPep) { _writer.WriteStartElement("terminal_modification"); if (singleSite.HasFlag(ModificationSites.NPep) || singleSite.HasFlag(ModificationSites.NProt)) { _writer.WriteAttributeString("terminus", "N"); basemass += AminoAcidPolymer.DefaultNTerminus.MonoisotopicMass; } else { _writer.WriteAttributeString("terminus", "C"); basemass += AminoAcidPolymer.DefaultCTerminus.MonoisotopicMass; } _writer.WriteAttributeString("protein_terminus", (singleSite.HasFlag(ModificationSites.NProt) || singleSite.HasFlag(ModificationSites.ProtC)) ? "Y" : "N"); } else { string letter = Enum.GetName(typeof(ModificationSites), singleSite); AminoAcid aa = AminoAcid.GetResidue(letter); _writer.WriteStartElement("aminoacid_modification"); _writer.WriteAttributeString("aminoacid", letter); basemass += aa.MonoisotopicMass; } double massshift = modification.MonoisotopicMass; _writer.WriteAttributeString("variable", (fixedModification) ? "N" : "Y"); _writer.WriteAttributeString("mass", (basemass + massshift).ToString()); _writer.WriteAttributeString("massdiff", massshift.ToString()); _writer.WriteAttributeString("description", modification.ToString()); _writer.WriteEndElement(); } }
private void Validate() { TransitionFilter.ValidateCharges(Resources.TransitionFilter_ProductCharges_Product_ion_charges, new[] { Charge }, Transition.MIN_PRODUCT_CHARGE, Transition.MAX_PRODUCT_CHARGE); if (IsFragment) { if (string.IsNullOrEmpty(Fragment)) { throw new InvalidDataException(Resources.MeasuredIon_Validate_Special_fragment_ions_must_have_at_least_one_fragmentation_residue); } AminoAcid.ValidateAAList(Fragment); if (!string.IsNullOrEmpty(Restrict)) { AminoAcid.ValidateAAList(Restrict); } if (!Terminus.HasValue) { throw new InvalidDataException(Resources.MeasuredIon_Validate_Special_fragment_ions_must_specify_the_terminal_side_of_the_amino_acid_residue_on_which_fragmentation_occurs); } if (MIN_MIN_FRAGMENT_LENGTH > MinFragmentLength || MinFragmentLength > MAX_MIN_FRAGMENT_LENGTH) { throw new InvalidDataException(string.Format(Resources.MeasuredIon_Validate_The_minimum_length__0__must_be_between__1__and__2__, MinFragmentLength, MIN_MIN_FRAGMENT_LENGTH, MAX_MIN_FRAGMENT_LENGTH)); } } else { if (SettingsCustomIon.MonoisotopicMass == 0 || SettingsCustomIon.AverageMass == 0) { throw new InvalidDataException(Resources.MeasuredIon_Validate_Reporter_ions_must_specify_a_formula_or_valid_monoisotopic_and_average_masses); } if (SettingsCustomIon.MonoisotopicMass < MIN_REPORTER_MASS || SettingsCustomIon.AverageMass < MIN_REPORTER_MASS) { throw new InvalidDataException(string.Format(Resources.MeasuredIon_Validate_Reporter_ion_masses_must_be_greater_than_or_equal_to__0__, MIN_REPORTER_MASS)); } if (SettingsCustomIon.MonoisotopicMass > MAX_REPORTER_MASS || SettingsCustomIon.AverageMass > MAX_REPORTER_MASS) { throw new InvalidDataException(string.Format(Resources.MeasuredIon_Validate_Reporter_ion_masses_must_be_less_than_or_equal_to__0__, MAX_REPORTER_MASS)); } } }
public static void WriteSearchEngineParams(string msmName, SilacLabel[] labels, bool addLabels, bool variableMods, SearchEngineParams msh, string titleSuffix) { if (addLabels) { for (int i = 0; i < labels.Length; i++) { if (variableMods) { msh.AddVariabeModification(AminoAcid.GetMascotModificationStringForLabel(labels[i])); } else { msh.AddFixedModification(AminoAcid.GetMascotModificationStringForLabel(labels[i])); } } } msh.Title += titleSuffix; msh.Write(msmName.Substring(0, msmName.Length - 4) + ".par"); }
public double GetFragmentScore(Composition prefixFragmentComposition, Composition suffixFragmentComposition, AminoAcid nTerminalResidue = null, AminoAcid cTerminalResidue = null) { var score = 0.0; var prefixMass = prefixFragmentComposition.Mass + _prefixOffsetMass; if (_ionMassBins.Contains(GetBinNumber(prefixMass))) { score += 1; } var suffixMass = suffixFragmentComposition.Mass + _suffixOffsetMass; if (_ionMassBins.Contains(GetBinNumber(suffixMass))) { score += 1; } return(score); }
private void Validate() { if (string.IsNullOrEmpty(CleavageC) && string.IsNullOrEmpty(CleavageN)) { throw new InvalidDataException(Resources.Enzyme_Validate_Enzymes_must_have_at_least_one_cleavage_point); } if (string.IsNullOrEmpty(CleavageC)) { if (!string.IsNullOrEmpty(RestrictC)) { throw new InvalidDataException(Resources.Enzyme_Validate_Enzyme_must_have_C_terminal_cleavage_to_have_C_terminal_restrictions_); } CleavageC = RestrictC = null; } else { AminoAcid.ValidateAAList(CleavageC); if (!string.IsNullOrEmpty(RestrictC)) { AminoAcid.ValidateAAList(RestrictC); } } if (string.IsNullOrEmpty(CleavageN)) { if (!string.IsNullOrEmpty(RestrictN)) { throw new InvalidDataException(Resources.Enzyme_Validate_Enzyme_must_have_N_terminal_cleavage_to_have_N_terminal_restrictions_); } CleavageN = RestrictN = null; } else { AminoAcid.ValidateAAList(CleavageN); if (!string.IsNullOrEmpty(RestrictN)) { AminoAcid.ValidateAAList(RestrictN); } } }
/// <summary> /// Gets the score at sequence cleavage summed for all ions that were selected during training. /// </summary> /// <param name="nTerminalFragmentComposition">Composition of NTerminal sequence cleavage.</param> /// <param name="cTerminalFragmentComposition">Composition of CTerminal sequence cleavage.</param> /// <param name="nTerminalResidue">Residue at NTerminal sequence cleavage.</param> /// <param name="cTerminalResidue">Residue at CTerminal sequence cleavage.</param> /// <returns>The summed score of all ions.</returns> public double GetFragmentScore( Composition nTerminalFragmentComposition, Composition cTerminalFragmentComposition, AminoAcid nTerminalResidue = null, AminoAcid cTerminalResidue = null) { double score = this.scoringParameters.FeatureWeights.Intercept; foreach (BaseIonType ionType in this.scoringParameters.SelectedIonTypes) { FeatureWeights featureVector = this.scoringParameters.FeatureWeights; Composition composition = ionType.IsPrefix ? nTerminalFragmentComposition : cTerminalFragmentComposition; AminoAcid residue = ionType.IsPrefix ? nTerminalResidue : cTerminalResidue; IEnumerable <Composition> offsetCompositions = ionType.GetPossibleCompositions(residue); double ionScore = 0.0; foreach (Composition offsetComp in offsetCompositions) // Iterate over possible compositions for the current base ion type { var ionComp = composition + offsetComp; var peak = this.ProductSpectrum.FindPeak(ionComp, this.scoringParameters.TrainerTolerance); if (peak == null) { continue; } // Use only the score of the best scoring composition option (we have all the beset scoring compositions!) var compScore = featureVector.GetMatchedIonPeakScoreWithError(ionType, peak, ionComp.Mass); if (compScore > ionScore) { ionScore = compScore; } } score += ionScore; } return(score); }
public void ValidateLookupWithZeroOffset() { string alphabetName = Utility._xmlUtil.GetTextValue(Constants.SimpleRnaAlphabetNode, Constants.AlphabetNameNode); string expectedSeq = Utility._xmlUtil.GetTextValue(Constants.CodonsNode, Constants.SequenceWithmoreThanTweleveChars); string expectedAminoAcid = Utility._xmlUtil.GetTextValue(Constants.CodonsNode, Constants.OffsetOneMoreThanTwelveCharsAminoAcid); string expectedOffset = Utility._xmlUtil.GetTextValue(Constants.CodonsNode, Constants.OffsetVaule4); ISequence seq = new Sequence(Utility.GetAlphabet(alphabetName), expectedSeq); // Validate Codons lookup method. AminoAcid aminoAcid = Codons.Lookup(seq, Convert.ToInt32(expectedOffset, null)); // Validate amino acids for a given sequence. Assert.AreEqual(aminoAcid.Name.ToString(), expectedAminoAcid); ApplicationLog.WriteLine(string.Format(null, "Translation P2: Amino Acid {0} is expected.", aminoAcid)); ApplicationLog.WriteLine( "Translation P2: Amino Acid validation for a given sequence was completed successfully."); }
public void ValidateLookupWithOffsetValueSix() { string alphabetName = _utilityObj._xmlUtil.GetTextValue( Constants.SimpleRnaAlphabetNode, Constants.AlphabetNameNode); string expectedSeq = _utilityObj._xmlUtil.GetTextValue( Constants.CodonsNode, Constants.ExpectedNormalString); string expectedAminoAcid = _utilityObj._xmlUtil.GetTextValue( Constants.CodonsNode, Constants.OffsetZeroSixCharsAminoAcid); string expectedOffset = _utilityObj._xmlUtil.GetTextValue( Constants.CodonsNode, Constants.OffsetVaule2); ISequence seq = new Sequence(Utility.GetAlphabet(alphabetName), expectedSeq); // Validate Codons lookup method. AminoAcid aminoAcid = Codons.Lookup(seq, Convert.ToInt32(expectedOffset, null)); // Validate amino acids for a given sequence. Assert.AreEqual(aminoAcid.Name.ToString((IFormatProvider)null), expectedAminoAcid); ApplicationLog.WriteLine(string.Format((IFormatProvider)null, "Translation P1: Amino Acid {0} is expected.", aminoAcid)); ApplicationLog.WriteLine( "Translation P1: Amino Acid validation for a given sequence was completed successfully."); }
public void ValidateAminoAcid() { // Get Node values from XML. string expectedNucleo = Utility._xmlUtil.GetTextValue( Constants.CodonsNode, Constants.Nucleotide); string expectedAminoAcid = Utility._xmlUtil.GetTextValue( Constants.CodonsNode, Constants.AminoAcid); // Create Nucleotide objects. Nucleotide firstNucleo1 = new Nucleotide(expectedNucleo[0], "Uracil"); Nucleotide firstNucleo2 = new Nucleotide(expectedNucleo[1], "Uracil"); Nucleotide firstNucleo3 = new Nucleotide(expectedNucleo[2], "Uracil"); // Validate Codons lookup method. AminoAcid aminoAcid = Codons.Lookup(firstNucleo1, firstNucleo2, firstNucleo3); // Validate amino acids for each triplet. Assert.AreEqual(aminoAcid.Name.ToString(), expectedAminoAcid); ApplicationLog.WriteLine(string.Format(null, "Translation BVT: Amino Acid {0} is expected.", aminoAcid)); ApplicationLog.WriteLine( "Translation BVT: Amino Acid validation for a given triplets of nucleotide was completed successfully."); }
private double GetScore( PSSMposition pos, AminoAcid aa ) { foreach( PSSMentry entry in pos.entries ) { if( entry.condition.Length == 1 ) { if( entry.condition.CompareTo(aa.Letter.ToString())==0 ) return entry.score; else continue; } switch( entry.condition.ToLower() ) { case "acidic": if( aa.Acidic ) return entry.score; break; case "basic": if( aa.Basic ) return entry.score; break; case "hydrophobic": if( aa.Hydrophobic ) return entry.score; break; case "polar": if( aa.Polar ) return entry.score; break; case "charge": if( aa.Charge != 0 ) return entry.score; break; case "positive": if( aa.Positive ) return entry.score; break; case "negative": if( aa.Negative ) return entry.score; break; case "aromatic": if( aa.Aromatic ) return entry.score; break; case "aliphatic": if( aa.Aliphatic ) return entry.score; break; default: throw new ApplicationException( "Undefined PSSM condition: " + entry.condition ); } } return 0.0; }
/// <summary> Creates amino acid AminoAcid objects. /// /// </summary> /// <returns> aminoAcids, a HashMap containing the amino acids as AminoAcids. /// </returns> public static AminoAcid[] createAAs() { if (aminoAcids != null) { return aminoAcids; } // Create set of AtomContainers aminoAcids = new AminoAcid[20]; IChemFile list = new ChemFile(); //UPGRADE_ISSUE: Method 'java.lang.ClassLoader.getResourceAsStream' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangClassLoader'" //UPGRADE_ISSUE: Method 'java.lang.Class.getClassLoader' was not converted. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1000_javalangClassgetClassLoader'" CMLReader reader = new CMLReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("NuGenCDKSharp." + "list_aminoacids.cml"));//typeof(AminoAcids).getClassLoader().getResourceAsStream("data/templates/list_aminoacids.cml")); try { list = (IChemFile)reader.read(list); IAtomContainer[] containers = ChemFileManipulator.getAllAtomContainers(list); for (int i = 0; i < containers.Length; i++) { //logger.debug("Adding AA: ", containers[i]); // convert into an AminoAcid AminoAcid aminoAcid = new AminoAcid(); IAtom[] atoms = containers[i].Atoms; System.Collections.IEnumerator props = containers[i].Properties.Keys.GetEnumerator(); //UPGRADE_TODO: Method 'java.util.Enumeration.hasMoreElements' was converted to 'System.Collections.IEnumerator.MoveNext' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationhasMoreElements'" while (props.MoveNext()) { //UPGRADE_TODO: Method 'java.util.Enumeration.nextElement' was converted to 'System.Collections.IEnumerator.Current' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilEnumerationnextElement'" System.Object next = props.Current; //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Class.getName' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.debug("Prop class: " + next.GetType().FullName); //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.debug("Prop: " + next.ToString()); if (next is DictRef) { DictRef dictRef = (DictRef)next; // System.out.println("DictRef type: " + dictRef.getType()); if (dictRef.Type.Equals("pdb:residueName")) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Object.toString' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" aminoAcid.setProperty(RESIDUE_NAME, containers[i].getProperty(dictRef).ToString().ToUpper()); } else if (dictRef.Type.Equals("pdb:oneLetterCode")) { aminoAcid.setProperty(RESIDUE_NAME_SHORT, containers[i].getProperty(dictRef)); } else if (dictRef.Type.Equals("pdb:id")) { aminoAcid.setProperty(ID, containers[i].getProperty(dictRef)); //logger.debug("Set AA ID to: ", containers[i].getProperty(dictRef)); } else { //logger.error("Cannot deal with dictRef!"); } } } for (int atomCount = 0; atomCount < atoms.Length; atomCount++) { IAtom atom = atoms[atomCount]; System.String dictRef = (System.String)atom.getProperty("org.openscience.cdk.dict"); if (dictRef != null && dictRef.Equals("pdb:nTerminus")) { aminoAcid.addNTerminus(atom); } else if (dictRef != null && dictRef.Equals("pdb:cTerminus")) { aminoAcid.addCTerminus(atom); } else { aminoAcid.addAtom(atom); } } IBond[] bonds = containers[i].Bonds; for (int bondCount = 0; bondCount < bonds.Length; bondCount++) { aminoAcid.addBond(bonds[bondCount]); } AminoAcidManipulator.removeAcidicOxygen(aminoAcid); aminoAcid.setProperty(NO_ATOMS, "" + aminoAcid.AtomCount); aminoAcid.setProperty(NO_BONDS, "" + aminoAcid.getBondCount()); if (i < aminoAcids.Length) { aminoAcids[i] = aminoAcid; } else { //logger.error("Could not store AminoAcid! Array too short!"); } } } catch (System.Exception exception) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.error("Failed reading file: ", exception.Message); //logger.debug(exception); } return aminoAcids; }
static void Add(NucleotidRna _1, NucleotidRna _2, NucleotidRna _3, AminoAcid acid) { var code = GetHashCode(_1, _2, _3); _translationTable.Add(code, acid); }
public static char ToChar(AminoAcid aminoAcid) { switch (aminoAcid) { case AminoAcid.G: return 'G'; case AminoAcid.A: return 'A'; case AminoAcid.V: return 'V'; case AminoAcid.L: return 'L'; case AminoAcid.I: return 'I'; case AminoAcid.P: return 'P'; case AminoAcid.F: return 'F'; case AminoAcid.Y: return 'Y'; case AminoAcid.W: return 'W'; case AminoAcid.S: return 'S'; case AminoAcid.T: return 'T'; case AminoAcid.D: return 'D'; case AminoAcid.E: return 'E'; case AminoAcid.N: return 'N'; case AminoAcid.Q: return 'Q'; case AminoAcid.C: return 'C'; case AminoAcid.M: return 'M'; case AminoAcid.H: return 'H'; case AminoAcid.K: return 'K'; case AminoAcid.R: return 'R'; case AminoAcid.Stop: return '*'; default: throw new ArgumentOutOfRangeException("aminoAcid"); } }