public ProteoformGroup(IReadOnlyList <IResidue> residues, IProteoformMassDelta?nTerminalModification, IProteoformMassDelta?cTerminalModification, IReadOnlyCollection <IProteoformLocalizedModification>?localizedModifications, IReadOnlyCollection <IProteoformUnlocalizedModification>?unlocalizedModifications, IReadOnlyCollection <IProteoformModificationGroup>?modificationGroups, IReadOnlyCollection <IProteoformGlobalModification>?globalModifications, IChemicalFormula water) { Residues = residues; NTerminalModification = nTerminalModification; CTerminalModification = cTerminalModification; LocalizedModifications = localizedModifications; UnlocalizedModifications = unlocalizedModifications; ModificationGroups = modificationGroups; GlobalModifications = globalModifications; Water = water; }
/// <summary> /// Saves the current modifications and isotopologues /// </summary> public static void SaveTo(string filePath) { using (XmlWriter writer = XmlWriter.Create(filePath, new XmlWriterSettings { Indent = true })) { writer.WriteStartDocument(); writer.WriteStartElement("Modifications"); foreach (var mod in Modifications.Values.Distinct()) { writer.WriteStartElement("Modification"); writer.WriteAttributeString("name", mod.Name); IChemicalFormula chemFormula = mod as IChemicalFormula; if (chemFormula != null) { writer.WriteElementString("ChemicalFormula", chemFormula.ToString()); } else { writer.WriteElementString("DeltaMass", mod.MonoisotopicMass.ToString("F10")); } foreach (ModificationSites site in mod.Sites.GetActiveSites()) { writer.WriteElementString("ModificationSite", site.ToString()); } foreach (KeyValuePair <string, Modification> mods in Modifications) { if (mods.Value.Equals(mod)) { writer.WriteElementString("AlternativeName", mods.Key); } } writer.WriteEndElement(); } writer.WriteEndElement(); // end Modifications writer.WriteEndDocument(); } }
/// <summary> /// Indicates whether the current object is equal to another object of the same type. /// </summary> /// <param name="other">An object to compare with this object.</param> /// <returns> /// true if the current object is equal to the <paramref name="other">other</paramref> parameter; otherwise, false. /// </returns> public bool Equals(IChemicalFormula other) { if (other == null) { return(false); } if (this == other) { return(true); } IReadOnlyCollection <IEntityCardinality <IElement> > otherElements = other.GetElements(); if (_elements.Count != otherElements.Count) { return(false); } if (_elements.Sum(x => x.Count) != otherElements.Sum(x => x.Count)) { return(false); } foreach (IEntityCardinality <IElement> element in _elements) { var otherElement = otherElements.SingleOrDefault(x => x.Entity.Equals(element.Entity)); // Check that the other chemical formula has this element. if (otherElement == null) { return(false); } // Check the counts. if (element.Count != otherElement.Count) { return(false); } } return(true); }
public void IsotopeTest() { const string formula = "C(-9) 13C(9)"; var composition = UnimodComposition.CreateFromFormula(formula, atomProvider); var cardinalities = composition.GetAtomCardinalities(); Assert.AreEqual(2, cardinalities.Count); Assert.AreEqual(atomProvider.GetUnimodCompositionAtom("C"), cardinalities[0].Atom); Assert.AreEqual(-9, cardinalities[0].Count); Assert.AreEqual(atomProvider.GetUnimodCompositionAtom("13C"), cardinalities[1].Atom); Assert.AreEqual(9, cardinalities[1].Count); IChemicalFormula chemicalFormula = composition.GetChemicalFormula(); var elements = chemicalFormula.GetElements(); Assert.AreEqual(2, elements.Count); Assert.AreEqual(-9, elements.Single(x => x.Entity.Symbol == "C").Count); Assert.AreEqual(9, elements.Single(x => x.Entity.Symbol == "13C").Count); }
/// <summary>Gets the chemical formula.</summary> /// <returns></returns> public IChemicalFormula GetChemicalFormula() { IChemicalFormula formula = ChemicalFormula.Empty; foreach (UnimodCompositionAtomCardinality atom in _atomCardinalities) { IChemicalFormula atomFormula = atom.Atom.GetChemicalFormula().Multiply(atom.Count); if (formula == null) { formula = atomFormula; } else { formula = formula.Add(atomFormula); } } return(formula); }
/// <summary> /// Adds the specified formula. /// </summary> /// <param name="otherFormula">The formula.</param> /// <returns></returns> public IChemicalFormula Add(IChemicalFormula otherFormula) { if (otherFormula == null) { return(this); } var otherElements = otherFormula.GetElements().ToList(); if (otherElements.Count == 0) { return(this); } var formula = new ChemicalFormula(); // Add everything from this formula foreach (var element in _elements) { var otherElement = otherElements.SingleOrDefault(x => x.Entity.Equals(element.Entity)); if (otherElement == null) { formula._elements.Add(element); } else { formula._elements.Add(new EntityCardinality <IElement>(element.Entity, element.Count + otherElement.Count)); otherElements.Remove(otherElement); } } // Add unique things from other formula foreach (var otherElement in otherElements) { formula._elements.Add(otherElement); } return(formula); }
private List <IChargedIsotopicDistribution> Mercury(IChemicalFormula cf, int firstcharge, int lastcharge, double limit) { IIsotopicDistribution dist = this.Mercury(cf, limit); var mercury7ResultList = new List <IChargedIsotopicDistribution>(); if (firstcharge > 0) { for (int j = firstcharge; j < lastcharge + 1; j++) { mercury7ResultList.Add(dist.CreateChargedDistribution(j)); } } else if (firstcharge < 0) { for (int j = firstcharge; j > lastcharge - 1; j--) { mercury7ResultList.Add(dist.CreateChargedDistribution(j, false)); } } return(mercury7ResultList); }
public ModificationWrapper(T modification, IChemicalFormula chemicalFormula) { this.Modification = modification; _chemicalFormula = chemicalFormula; }
/// <summary>Attempts to parse the string into a ChemicalFormula.</summary> /// <param name="formula">The chemical formula as a string.</param> /// <param name="elementProvider">The element provider.</param> /// <param name="chemicalFormula">The chemical formula or null if string was not formatted correctly.</param> /// <returns>True if successful, otherwise false.</returns> public static bool TryParseString(ReadOnlySpan <char> formula, IElementProvider elementProvider, out IChemicalFormula chemicalFormula) { chemicalFormula = ChemicalFormula.Empty; // Set to null in case of failure. IDictionary <string, IEntityCardinality <IElement> > elementList = new Dictionary <string, IEntityCardinality <IElement> >(); int symbolStart = 0, symbolEnd = 0; int digitStart = 0, digitEnd = 0; int isotopeStart = 0, isotopeEnd = 0; bool sawUpperCaseLetter = false; for (int i = 0; i < formula.Length; i++) { // Check to see if this is the start of a new element if (i > 0 && (formula[i] == '[' || (sawUpperCaseLetter && char.IsUpper(formula[i])))) { if (!HandleNewElement(formula, elementProvider, elementList, symbolStart, symbolEnd, digitStart, digitEnd, isotopeStart, isotopeEnd)) { return(false); } // Reset things sawUpperCaseLetter = false; digitStart = 0; digitEnd = 0; isotopeStart = 0; isotopeEnd = 0; } if (formula[i] == '[') { isotopeStart = i++ + 1; } else if (formula[i] == ']') { // Ignore because a new element is starting on the next loop } else if (char.IsLetter(formula[i])) { if (char.IsUpper(formula[i])) { // New element sawUpperCaseLetter = true; symbolStart = i; symbolEnd = i; if (isotopeStart != 0) { isotopeEnd = i - 1; } } else { // Lowercase letter continuing the current element. symbolEnd = i; } } else if (isotopeStart != 0 && isotopeEnd == 0) { // In an isotope block looking for isotope numbers, do nothing } else if (formula[i] == '-') { // Handle negative cardinalities if (digitStart == 0) { digitStart = i; digitEnd = i; } } else if (char.IsNumber(formula[i])) { if (digitStart == 0) { digitStart = i; } digitEnd = i; } else if (char.IsWhiteSpace(formula[i])) { // Ignore white space } else { // Known character, fail! return(false); } } // Add the last element if (!HandleNewElement(formula, elementProvider, elementList, symbolStart, symbolEnd, digitStart, digitEnd, isotopeStart, isotopeEnd)) { return(false); } // Success! chemicalFormula = new ChemicalFormula(elementList.Values); return(true); }
/// <summary> /// Generates the isotopic distribution. /// </summary> /// <param name="chemicalFormula">The chemical formula.</param> /// <param name="fineResolution">The fine resolution.</param> /// <param name="minProbability">The minimum probability.</param> /// <returns></returns> public IIsotopicDistribution GenerateIsotopicDistribution(IChemicalFormula chemicalFormula, double fineResolution, double minProbability) { return(this.GetDistribution(chemicalFormula, fineResolution, minProbability, defaultMolecularWeightResolution)); }
public MZSpectrum CalculateDistribuition(IChemicalFormula obj, int topNPeaks = int.MaxValue, Normalization normalization = Normalization.Sum) { return(CalculateDistribuition(obj.ChemicalFormula, topNPeaks, normalization)); }
private IChargedIsotopicDistribution Mercury(IChemicalFormula cf, int charge, double limit) { return(this.Mercury(cf, charge, charge, limit).Single()); }
/// <summary> /// Generates a list of charged isotopic distributions using the Mercury algorithm. /// </summary> /// <param name="chemicalFormula">The chemical formula.</param> /// <param name="firstCharge">The first charge.</param> /// <param name="lastCharge">The last charge.</param> /// <returns></returns> public IList <IChargedIsotopicDistribution> GenerateChargedIsotopicDistributions(IChemicalFormula chemicalFormula, int firstCharge, int lastCharge) { return(this.Mercury(chemicalFormula, firstCharge, lastCharge, this._limit)); }
/// <summary> /// Calculates the expected charged isotopic distribution for a given composition and charge. /// </summary> /// <param name="chemicalFormula">The chemical formula.</param> /// <param name="charge">The charge.</param> /// <returns></returns> public IChargedIsotopicDistribution GenerateChargedIsotopicDistribution(IChemicalFormula chemicalFormula, int charge) { return(this.Mercury(chemicalFormula, charge, this._limit)); }
/// <summary> /// Calculates the expected isotopic distribution for a given composition. /// </summary> /// <param name="chemicalFormula">The chemical formula.</param> /// <returns></returns> public IIsotopicDistribution GenerateIsotopicDistribution(IChemicalFormula chemicalFormula) { return(this.Mercury(chemicalFormula, this._limit)); }
public MZSpectrum CalculateDistribuition(IChemicalFormula obj, int topNPeaks = int.MaxValue, Normalization normalization = Normalization.Sum) { return CalculateDistribuition(obj.ChemicalFormula, topNPeaks, normalization); }
private IIsotopicDistribution Mercury(IChemicalFormula cf, double limit) { // Build up the molecular super atom (MSA) until it is the entire molecule // A "molecular super atom" refers to a fictitious chemical compound whose // formula is a partial composition of the target compound. double[]? msaMz = null; double[]? msaAbundance = null; double[]? tmpMz = null; double[]? tmpAbundance = null; bool msaInitialized = false; foreach (IEntityCardinality <IElement> kvp in cf.GetElements()) { uint n = (uint)kvp.Count; if (n == 0) { continue; } int isotopeCount = kvp.Entity.Isotopes.Count; double[] esaMz = new double[isotopeCount]; double[] esaAbundance = new double[isotopeCount]; int i = 0; foreach (var iso in kvp.Entity.Isotopes.OrderBy(x => x.AtomicMass)) // Algorithm requires it to be sorted. { esaMz[i] = iso.AtomicMass; esaAbundance[i] = iso.RelativeAbundance; i++; } while (true) { // This is an implicit FFT that decomposes the number of a particular element // into the sum of its powers of 2. // Check if we need to do the MSA update - only if n is odd if ((n & 1) == 1) { // MSA update if (msaInitialized) { // normal update Convolve(ref tmpMz, ref tmpAbundance, msaMz, msaAbundance, esaMz, esaAbundance); msaMz = this.CopyArray(tmpMz); msaAbundance = this.CopyArray(tmpAbundance); } else { // for first assignment, MSA = ESA msaMz = this.CopyArray(esaMz); msaAbundance = this.CopyArray(esaAbundance); msaInitialized = true; } Prune(ref msaMz, ref msaAbundance, limit); } // The ESA update is always carried out (with the exception of the last time, i.e., when n == 1) if (n == 1) { break; } Convolve(ref tmpMz, ref tmpAbundance, esaMz, esaAbundance, esaMz, esaAbundance); esaMz = this.CopyArray(tmpMz); esaAbundance = this.CopyArray(tmpAbundance); Prune(ref esaMz, ref esaAbundance, limit); n = n >> 1; } } if (msaMz != null && msaAbundance != null) { return(new IsotopicDistribution(msaMz, msaAbundance)); } throw new Exception("Couldn't create masses or abundances."); }
/// <summary> /// Create an chemical formula from an item that contains a chemical formula /// </summary> /// <param name="item">The item of which a new chemical formula will be made from</param> public ChemicalFormula(IChemicalFormula item) : this(item.ChemicalFormula) { }
public FormulaModification(IChemicalFormula chemicalFormula) { _chemicalFormula = chemicalFormula; }