/// <summary> /// Add the given multiple of mf into to. /// </summary> /// <param name="to"></param> /// <param name="mf"></param> /// <param name="multiple"></param> private void Add(MolecularFormula to, MolecularFormula mf, int multiple) { foreach (String s in mf.elementCounts.Keys) { to.Add(s, ((int)mf.elementCounts[s]) * multiple); } }
/// <summary> /// Add the given multiple of formulaToAdd into targetFormula /// </summary> /// <param name="targetFormula"></param> /// <param name="formulaToAdd"></param> /// <param name="multiple"></param> private void Add(MolecularFormula targetFormula, MolecularFormula formulaToAdd, int multiple) { foreach (var item in formulaToAdd.elementCounts) { targetFormula.Add(item.Key, item.Value * multiple); } }
public MolecularFormula GetAveragineFormula(double mz, int chargeState) { var monoIsotopicMass = mz * chargeState - chargeState * decon2LSMercuryDistribution.ChargeCarrierMass; var empiricalFormula = averagineFormulaCreator.GenerateAveragineFormula(monoIsotopicMass); return(MolecularFormula.Parse(empiricalFormula)); }
public MolecularFormula GetAveragineFormula(double mz, int chargeState) { double monoIsotopicMass = mz * chargeState - chargeState * hornParameters.CCMass; string empiricalFormula = avergineFormulaCreator.GenerateAveragineFormula(monoIsotopicMass, hornParameters.AveragineFormula, hornParameters.TagFormula); return(MolecularFormula.Parse(empiricalFormula)); }
public void CreateDistribution(double mass, int chargeState, double resolution) { string empiricalFormula = avergineFormulaCreator.GenerateAveragineFormula(mass, hornParameters.AveragineFormula, hornParameters.TagFormula); this.molecularFormula = MolecularFormula.Parse(empiricalFormula); this.resolution = resolution; this.chargeState = chargeState; CreateDistribution(this.molecularFormula); }
public void CreateDistribution(double mass, int chargeState, double resolution) { var empiricalFormula = averagineFormulaCreator.GenerateAveragineFormula(mass); MolecularFormula = MolecularFormula.Parse(empiricalFormula); Resolution = resolution; ChargeState = chargeState; CreateDistribution(MolecularFormula); }
public void Add(String part, MolecularFormula mf) { if (part == null) { throw new ArgumentNullException("part"); } if (mf == null) { throw new ArgumentNullException("mf"); } partFormulas.Add(part, mf); }
public void Set(String part, MolecularFormula mf) { if (part == null) { throw new ArgumentNullException("part"); } if (mf == null) { throw new ArgumentNullException("mf"); } this.partFormulas.Remove(part); this.Add(part, mf); }
public MolecularFormula Add(MolecularFormula mf, int multiple, bool permitNegativeMultiple) { if (multiple < 0 && !permitNegativeMultiple) { throw new ArgumentOutOfRangeException("multiple", multiple, "Multiple must be >= 0"); } var newFormula = new MolecularFormula(this); newFormula.name = null; newFormula.formulaString = null; Add(newFormula, mf, multiple); return(newFormula); }
public static MolecularFormula Parse(string formula, string name, bool allowNegatives) { if (formula == null) { throw new ArgumentNullException(nameof(formula)); } var match = parsingRegex.Match(formula); if (!match.Success) { throw new ApplicationException("Formula can not be parsed"); } var mf = new MolecularFormula(); var matched = match.Groups["element"].Captures.Count; //Console.WriteLine("Num Groups {0}", matched); // Iterate through the matched groups, updating element counts for (var i = 0; i < matched; i++) { var element = match.Groups["element"].Captures[i].Value; var count = match.Groups["count"].Captures[i].Value; //Console.WriteLine("Element {0}, Count {1}", element, count); // If the symbol is unknown, throw an exception. // The multiple defaults to 1 if not found. So CHHCHH is C2 H4. var multiple = 1; if (count != "") { try { multiple = int.Parse(count); if (multiple < 0 && !allowNegatives) { throw new ApplicationException("Negative multiple " + multiple + " for element " + element + " is not allowed."); } } // This can never actually happen, because the regex makes sure that // only integer values which can be parsed make it to this stage catch (Exception ex) { throw new ApplicationException("The multiple for element " + element + ", " + count + ", was not parseable", ex); } } mf.Add(element, multiple); } mf.formulaString = formula; mf.name = name; return(mf); }
public void Add(string part, MolecularFormula mf) { if (part == null) { throw new ArgumentNullException(nameof(part)); } if (mf == null) { throw new ArgumentNullException(nameof(mf)); } // This will raise an exception if partFormulas already contains the part string partFormulas.Add(part, mf); }
public void CreateDistribution(MolecularFormula molecularFormula) { Check.Require(molecularFormula != null, "Molecular formula has not been defined."); this.molecularFormula = molecularFormula; this.data = new XYData(); //clears any old data this.elementTable = molecularFormula.ToElementTable(); this.decon2LSMercuryDistribution = new DeconToolsV2.clsMercuryIsotopeDistribution(); this.decon2LSMercuryDistribution.Resolution = this.resolution; this.decon2LSMercuryDistribution.ChargeState = (short)this.chargeState; System.Drawing.PointF[] drawingpoints = this.decon2LSMercuryDistribution.CalculateDistribution(this.elementTable); this.data = XYData.ConvertDrawingPoints(drawingpoints); }
public void CreateDistribution(MolecularFormula molecularFormula) { Check.Require(molecularFormula != null, "Molecular formula has not been defined."); MolecularFormula = molecularFormula; Data = new XYData(); //clears any old data var deconToolsMolFormula = ProcessingTasks.Deconvoluters.HornDeconvolutor.ThrashV1.ElementalFormulas.MolecularFormula.ConvertFromString(molecularFormula.ToFormulaString()); decon2LSMercuryDistribution = new ProcessingTasks.Deconvoluters.HornDeconvolutor.ThrashV1.Mercury.MercuryIsotopeDistribution(); decon2LSMercuryDistribution.CalculateDistribution(ChargeState, Resolution, deconToolsMolFormula, out var x, out var y, 0, out _, out _); Data = new XYData() { Xvalues = x.ToArray(), Yvalues = y.ToArray() }; }
public void Set(string part, MolecularFormula mf) { if (part == null) { throw new ArgumentNullException(nameof(part)); } if (mf == null) { throw new ArgumentNullException(nameof(mf)); } if (partFormulas.ContainsKey(part)) { partFormulas.Remove(part); } Add(part, mf); }
public MolecularFormula Translate(string input, string partRegex) { try { var regex = new Regex(partRegex); var formula = new MolecularFormula(); var matches = regex.Matches(input); foreach (Match match in matches) { if (!partFormulas.TryGetValue(match.Value, out var partFormula)) { throw new ApplicationException("Formula for part " + match.Value + " is unknown."); } formula = formula.Add(partFormula, 1); } return(formula); } catch (Exception e) { throw new ApplicationException("Translation of " + input + " failed. " + e.Message, e); } }
public MolecularFormula Translate(String input, String partRegex) { try { var regex = new Regex(partRegex); var formula = new MolecularFormula(); var matches = regex.Matches(input); foreach (Match match in matches) { var partFormula = (MolecularFormula)this.partFormulas[match.Value]; if (partFormula == null) { throw new ApplicationException("Formula for part " + match.Value + " is unknown."); } formula = formula.Add(partFormula, 1); } return(formula); } catch (Exception e) { throw new ApplicationException("Translation of " + input + " failed. " + e.Message, e); } }
/// <summary> /// Clones the formula. /// </summary> /// <param name="formula"></param> private MolecularFormula(MolecularFormula formula) { this.name = formula.name; this.formulaString = formula.formulaString; this.elementCounts = new Hashtable(formula.elementCounts); }
/// <summary> /// Create a new MolecularFormula by adding the given formula (times the given multiple) /// to this formula. /// </summary> /// <param name="mf"></param> /// <param name="multiple"></param> /// <returns></returns> public MolecularFormula Add(MolecularFormula mf, int multiple) { return(Add(mf, multiple, false)); }
/// <summary> /// Clones the formula. /// </summary> /// <param name="formula"></param> private MolecularFormula(MolecularFormula formula) { name = formula.name; formulaString = formula.formulaString; elementCounts = new Dictionary <string, int>(formula.elementCounts); }