public virtual void TestClone_IMolecualrFormula()
{
IMolecularFormulaSet mfS = Builder.NewMolecularFormulaSet();
IMolecularFormula mf1 = Builder.NewMolecularFormula();
IIsotope carb = Builder.NewIsotope("C");
IIsotope flu = Builder.NewIsotope("F");
IIsotope h1 = Builder.NewIsotope("H");
mf1.Add(carb);
mf1.Add(flu);
mf1.Add(h1, 3);
mfS.Add(mf1);
IMolecularFormula mf2 = Builder.NewMolecularFormula();
IIsotope carb2 = Builder.NewIsotope("C");
IIsotope iode = Builder.NewIsotope("I");
IIsotope h2 = Builder.NewIsotope("H");
mf2.Add(carb2);
mf2.Add(iode, 2);
mf2.Add(h2, 2);
mfS.Add(mf2);
object clone = mfS.Clone();
Assert.IsTrue(clone is IMolecularFormulaSet);
Assert.AreNotSame(mfS, clone);
Assert.AreEqual(mfS.Count(), ((IMolecularFormulaSet)clone).Count());
Assert.AreEqual(mfS[0].IsotopesCount, ((IMolecularFormulaSet)clone)
[0].IsotopesCount);
Assert.AreEqual(mfS[1].IsotopesCount, ((IMolecularFormulaSet)clone)
[1].IsotopesCount);
}
public string MolFormula => GetMolecularFormula(NativeMol); // get mol formula
/// <summary>
/// GetMolecularFormula
/// </summary>
/// <param name="mol"></param>
/// <returns></returns>
public static string GetMolecularFormula(IAtomContainer mol)
{
IMolecularFormula moleculeFormula = MolecularFormulaManipulator.getMolecularFormula(mol);
String formula = MolecularFormulaManipulator.getString(moleculeFormula);
return(formula);
}
/// <summary>
/// Clear the isotope information from isotopes that are major (e.g.
/// <sup>12</sup>C, <sup>1</sup>H, etc).
/// </summary>
/// <param name="formula">the formula</param>
public static void ClearMajorIsotopes(IMolecularFormula formula)
{
var isotopesToRemove = new List <IIsotope>();
var isotopesToAdd = new List <Tuple <IIsotope, int> >();
foreach (var iso in formula.Isotopes.Where(n => IsMajor(n)))
{
var count = formula.GetCount(iso);
isotopesToRemove.Add(iso);
iso.MassNumber = null;
// may be immutable
var iso_ = iso;
if (iso_.MassNumber != null)
{
iso_ = formula.Builder.NewIsotope(iso_.Symbol);
}
iso_.ExactMass = null;
iso_.Abundance = null;
isotopesToAdd.Add(new Tuple <IIsotope, int>(iso_, count));
}
foreach (var isotope in isotopesToRemove)
{
formula.Remove(isotope);
}
foreach (var t in isotopesToAdd)
{
formula.Add(t.Item1, t.Item2);
}
}
public virtual void TestSetProperty_Object_Object()
{
IMolecularFormula mf = Builder.NewMolecularFormula();
mf.SetProperty("blabla", 2);
Assert.IsNotNull(mf.GetProperty <object>("blabla"));
}
public void TestDefaultValidFalse()
{
IRule rule = new NitrogenRule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C2H4", builder);
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public virtual void TestGetIsotope_Number_Clone()
{
IMolecularFormula mf = Builder.NewMolecularFormula();
IIsotope carb = Builder.NewIsotope("C");
IIsotope flu = Builder.NewIsotope("F");
IIsotope h1 = Builder.NewIsotope("H");
mf.Add(carb);
mf.Add(flu);
mf.Add(h1, 3);
object clone = mf.Clone();
Assert.IsTrue(clone is IMolecularFormula);
IMolecularFormula cloneFormula = (IMolecularFormula)clone;
Assert.AreEqual(1, cloneFormula.GetCount(carb));
Assert.AreEqual(1, cloneFormula.GetCount(flu));
Assert.AreEqual(3, cloneFormula.GetCount(h1));
// In a List the objects are not stored in the same order than called
// Assert.AreEqual("C", cloneFormula.Isotopes[0].Symbol);
// Assert.AreEqual("F", cloneFormula.Isotopes[1].Symbol);
// Assert.AreEqual("H", cloneFormula.Isotopes[2].Symbol);
}
public void TestNewMolecularFormula()
{
IChemObjectBuilder builder = RootObject.Builder;
IMolecularFormula mf = builder.NewMolecularFormula();
Assert.IsNotNull(mf);
}
public virtual void TestInstance_IIsotope()
{
IMolecularFormula mf = Builder.NewMolecularFormula();
IIsotope carb = Builder.NewIsotope("C");
IIsotope flu = Builder.NewIsotope("F");
IIsotope h1 = Builder.NewIsotope("H");
mf.Add(carb);
mf.Add(flu);
mf.Add(h1, 3);
IEnumerator <IIsotope> istoIter = mf.Isotopes.GetEnumerator();
Assert.IsNotNull(istoIter);
Assert.IsTrue(istoIter.MoveNext());
IIsotope next = istoIter.Current;
Assert.IsTrue(next is IIsotope);
// Assert.AreEqual(carb, next);
Assert.IsTrue(istoIter.MoveNext());
next = istoIter.Current;
Assert.IsTrue(next is IIsotope);
// Assert.AreEqual(flu, next);
Assert.IsTrue(istoIter.MoveNext());
next = istoIter.Current;
Assert.IsTrue(next is IIsotope);
// Assert.AreEqual(h1, next);
Assert.IsFalse(istoIter.MoveNext());
}
public void TestGetFormula()
{
IsotopeContainer isoC = new IsotopeContainer();
IMolecularFormula formula = builder.NewMolecularFormula();
isoC.Formula = formula;
Assert.AreEqual(formula, isoC.Formula);
}
public void TestSetFormula_IMolecularFormula()
{
IsotopeContainer isoC = new IsotopeContainer();
IMolecularFormula formula = builder.NewMolecularFormula();
isoC.Formula = formula;
Assert.IsNotNull(isoC);
}
public void TestAnticipatedIonState_2()
{
RDBERule rule = new RDBERule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("NH4", builder);
Assert.AreEqual(0.0, rule.Validate(formula), 0.0001);
}
public void TestGetIsotopesIMolecularFormulaWithoutONE()
{
IMolecularFormula molFor = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C41H79N8O3P", builder);
IsotopePatternGenerator isotopeGe = new IsotopePatternGenerator(.01);
IsotopePattern isos = isotopeGe.GetIsotopes(molFor);
Assert.AreEqual(6, isos.Isotopes.Count, 0.001);
}
private IMolecularFormula Union(IMolecularFormula a, IMolecularFormula b)
{
var mf = builder.NewMolecularFormula();
mf.Add(a);
mf.Add(b);
return(mf);
}
[TestMethod(), Ignore()] //Non-deterministic test value is bad! This likely depends on our current isotope data which is also bad.
public void TestCalculateIsotopesC20H30Fe2P2S4Cl4()
{
IMolecularFormula molFor = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C20H30Fe2P2S4Cl4", builder);
IsotopePatternGenerator isotopeGe = new IsotopePatternGenerator(.01);
IsotopePattern isos = isotopeGe.GetIsotopes(molFor);
Assert.IsTrue(isos.Isotopes.Count == 34 || isos.Isotopes.Count == 35);
}
public virtual void TestGetProperties()
{
IMolecularFormula mf = Builder.NewMolecularFormula();
mf.SetProperty("blabla", 2);
mf.SetProperty("blabla3", 3);
Assert.AreEqual(2, mf.GetProperties().Count());
}
public void TestValidate_IMolecularFormula_Double()
{
RDBERule rule = new RDBERule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C2H4", builder);
Assert.IsTrue(rule.Validate(formula, 2.0));
}
public void Test2()
{
RDBERule rule = new RDBERule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C4H8O3S1", builder);
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public void TestGetRDBEValue_IMolecularFormula()
{
RDBERule rule = new RDBERule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C2H4", builder);
Assert.AreEqual(1.0, rule.GetRDBEValue(formula)[0], 0.0001);
}
public virtual void TestGetBuilder()
{
IMolecularFormula add = Builder.NewMolecularFormula();
IChemObjectBuilder builder = add.Builder;
Assert.IsNotNull(Builder);
Assert.AreEqual(Builder.GetType().Name, builder.GetType().Name);
}
public virtual void TestMolecularFormula_NullCharge()
{
IMolecularFormula mf = Builder.NewMolecularFormula();
IMolecularFormula mf2 = Builder.NewMolecularFormula();
mf2.Charge = 0;
mf.Add(mf2);
}
/// <summary>
/// Constructor of the <see cref="IsotopeContainer"/> object setting a <see cref="IMolecularFormula"/> object and intensity value.
/// </summary>
/// <param name="formula">The formula of this container</param>
/// <param name="intensity">The intensity of this container</param>
public IsotopeContainer(IMolecularFormula formula, double intensity)
{
forms.Add(formula);
if (formula != null)
{
Mass = MolecularFormulaManipulator.GetTotalExactMass(formula);
}
Intensity = intensity;
}
/// <summary>
/// Get all combinatorial chemical isotopes given a structure.
/// </summary>
/// <param name="molFor">The IMolecularFormula to start</param>
/// <returns>A IsotopePattern object containing the different combinations</returns>
public IsotopePattern GetIsotopes(IMolecularFormula molFor)
{
if (builder == null)
{
try
{
isoFactory = CDK.IsotopeFactory;
builder = molFor.Builder;
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
var mf = MolecularFormulaManipulator.GetString(molFor, true);
var molecularFormula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula(mf, builder);
IsotopePattern abundance_Mass = null;
foreach (var isos in molecularFormula.Isotopes)
{
var elementSymbol = isos.Symbol;
var atomCount = molecularFormula.GetCount(isos);
// Generate possible isotope containers for the current atom's
// these will then me 'multiplied' with the existing patten
var additional = new List <IsotopeContainer>();
foreach (var isotope in isoFactory.GetIsotopes(elementSymbol))
{
double mass = isotope.ExactMass.Value;
double abundance = isotope.Abundance.Value;
if (abundance <= 0.000000001)
{
continue;
}
IsotopeContainer container = new IsotopeContainer(mass, abundance);
if (storeFormula)
{
container.Formula = AsFormula(isotope);
}
additional.Add(container);
}
for (int i = 0; i < atomCount; i++)
{
abundance_Mass = CalculateAbundanceAndMass(abundance_Mass, additional);
}
}
var isoP = IsotopePatternManipulator.SortAndNormalizedByIntensity(abundance_Mass);
isoP = CleanAbundance(isoP, minIntensity);
var isoPattern = IsotopePatternManipulator.SortByMass(isoP);
return(isoPattern);
}
public void TestWithCo()
{
IRule rule = new NitrogenRule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMolecularFormula("C43H50CoN4O16", builder);
formula.Charge = 0;
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public void TestWithFe()
{
IRule rule = new NitrogenRule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMolecularFormula("C40H46FeN6O8S2", builder);
formula.Charge = 2;
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public void TestC45H75NO15()
{
IRule rule = new NitrogenRule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C45H75NO15", builder);
formula.Charge = 0;
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public void TestB()
{
RDBERule rule = new RDBERule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C6H9BNO2", builder);
formula.Charge = 1;
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public void TestDefaultValidTrue()
{
IRule rule = new RDBERule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMajorIsotopeMolecularFormula("C1H4", builder);
formula.Charge = 0;
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public void TestIsotopeContainer_IMolecularFormula_Double()
{
IMolecularFormula formula = builder.NewMolecularFormula();
double intensity = 130.00;
IsotopeContainer isoC = new IsotopeContainer(formula, intensity);
Assert.IsNotNull(isoC);
Assert.AreEqual(formula, isoC.Formula);
Assert.AreEqual(intensity, isoC.Intensity, 0.001);
}
/// <summary>
/// Validate the isotope pattern of this <see cref="IMolecularFormula"/>. Important, first
/// you have to add with the <see cref="Parameters"/> a <see cref="IMolecularFormulaSet"/>
/// which represents the isotope pattern to compare.
/// </summary>
/// <param name="formula">Parameter is the <see cref="IMolecularFormula"/></param>
/// <returns>A double value meaning 1.0 True, 0.0 False</returns>
public double Validate(IMolecularFormula formula)
{
Trace.TraceInformation("Start validation of ", formula);
IsotopePatternGenerator isotopeGe = new IsotopePatternGenerator(0.1);
IsotopePattern patternIsoPredicted = isotopeGe.GetIsotopes(formula);
IsotopePattern patternIsoNormalize = IsotopePatternManipulator.Normalize(patternIsoPredicted);
return(isotopePatternSimilarity.Compare(pattern, patternIsoNormalize));
}
public void TestDoubleCharge()
{
IRule rule = new NitrogenRule();
IMolecularFormula formula = MolecularFormulaManipulator.GetMolecularFormula("C22H34N2S2", builder);
formula.Charge = 2;
Assert.AreEqual(1.0, rule.Validate(formula), 0.0001);
}
public NeutralLoss(IMolecularFormula elementalComposition, IMolecularFormula topoFragment, int mode, int hydrogenDifference, int distance, string atomToStart, int hydrogenOnStartAtom)
{
this.elementalComposition = elementalComposition;
this.mode = mode;
this.topoFragment = topoFragment;
this.hydrogenDifference = hydrogenDifference;
this.distance = distance;
this.atomToStart = atomToStart;
this.hydrogenOnStartAtom = hydrogenOnStartAtom;
}
public static Dictionary<string, double> ParseFormula(IMolecularFormula formula)
{
var parsedFormula = new Dictionary<string, double>();
var elements = MolecularFormulaManipulator.elements(formula);
foreach (var element in elements.ToWindowsEnumerable<IElement>())
{
var elementCount = MolecularFormulaManipulator.getElementCount(formula, element);
var symbol = element.getSymbol();
var a = new Atom(symbol);
var isofac = IsotopeFactory.getInstance(new ChemObject().getBuilder());
isofac.configure(a);
var mass = a.getExactMass().doubleValue();
mass = mass * elementCount;
parsedFormula[symbol] = mass;
}
return parsedFormula;
}
// This is ported from the CDK and modified to not do so much uneccessary looping
public static string GetString(IMolecularFormula formula)
{
var carbon = new Element("C");
var poossibleElements = MolecularFormulaManipulator.containsElement(formula, carbon) ? HillSystem.ElementsWithCarbons : HillSystem.ElementsWithoutCarbons;
var elemCounts = new OrderedDictionary();
foreach (var possibleElement in poossibleElements)
{
elemCounts.Add(possibleElement, 0);
}
foreach (var isotope in formula.isotopes().ToWindowsEnumerable<IIsotope>())
{
var isotopeSymbol = isotope.getSymbol();
var currentCount = (int)elemCounts[isotopeSymbol];
elemCounts[isotopeSymbol] = currentCount + formula.getIsotopeCount(isotope);
}
var parts = new List<string>();
foreach (DictionaryEntry elemCount in elemCounts)
{
var count = (int)elemCount.Value;
var elem = (string)elemCount.Key;
if (count == 1)
{
parts.Add(elem);
}
else if (count > 1)
{
parts.Add(string.Format("{0}{1}", elem, count));
}
}
return string.Join("", parts);
}
public static double GetMonoisotopicMass(IMolecularFormula formula)
{
return MolecularFormulaManipulator.getTotalExactMass(formula);
}
public static bool IsPossibleNeutralLoss(Dictionary<string, double> originalFormulaMap, IMolecularFormula neutralLossFormula)
{
var isPossible = false;
var neutralLossFormulaMap = ParseFormula(neutralLossFormula);
foreach (var element in neutralLossFormulaMap.Keys)
{
var massElementOrig = 0.0;
if (originalFormulaMap.TryGetValue(element, out massElementOrig))
{
var massNeutralLoss = neutralLossFormulaMap[element];
if ((massElementOrig - massNeutralLoss) < 0)
{
isPossible = false;
break;
}
else
{
//neutral loss is possible with this formula
isPossible = true;
}
}
//element not contained in candidate fragment
else
{
break;
}
}
return isPossible;
}
/**
* Adds the neutral losses but only where it possibly explaines a peak.
* Properties to be set seperated by ",", each column is one "entry":
* <ul>
* <li>Neutral loss list: elemental composition (-H2O,-HCOOH,CO2)
* <li>Neutral loss masses (18.01056, 46.00548, 43.98983)
* <li>Hydrogen difference (-H,-H,+H)
* <li>Current fragment mass...a single value (147.0232)
* </ul>
*
* @param fragment the fragment
* @param fragmentFormula the fragment formula
* @param initialMolecule the initial molecule only important for the start
*
* @return the list< i atom container>
*
* @throws IOException Signals that an I/O exception has occurred.
* @throws CloneNotSupportedException the clone not supported exception
* @throws CDKException the CDK exception
*/
private IEnumerable<IAtomContainer> AddNeutralLosses(IAtomContainer fragment, IMolecularFormula fragmentFormula, bool initialMolecule)
{
var ret = new List<IAtomContainer>();
var mass = MolecularFormulaTools.GetMonoisotopicMass(fragmentFormula);
var originalFormulaMap = MolecularFormulaTools.ParseFormula(fragmentFormula);
var checked_ = false;
//in the first layer add all neutral losses!!! afterwards only if it matches a peak!
foreach (var peak in peakList)
{
if (initialMolecule && checked_)
{
break;
}
var peakLow = peak.Mass - config.Mzabs - PpmTool.GetPPMDeviation(peak.Mass, config.Mzppm);
var peakHigh = peak.Mass + config.Mzabs + PpmTool.GetPPMDeviation(peak.Mass, config.Mzppm);
checked_ = true;
foreach (var neutralLossMass in neutralLoss.Keys)
{
//filter appropriate neutral losses by mode...0 means this occurs in both modes
if (neutralLoss[neutralLossMass].Mode == config.Mode || neutralLoss[neutralLossMass].Mode == 0)
{
var neutralLossFormula = neutralLoss[neutralLossMass].ElementalComposition;
var isPossibleNeutralLoss = MolecularFormulaTools.IsPossibleNeutralLoss(originalFormulaMap, neutralLossFormula);
if ((isPossibleNeutralLoss && ((mass + protonMass) - neutralLossMass) >= peakLow && (((mass + protonMass) - neutralLossMass) <= peakHigh)) || initialMolecule)
{
var fragmentsNL = pp.PostProcess(fragment, neutralLossMass);
foreach (var x in fragmentsNL)
{
var fragmentNL = x;
var fragmentMolFormula = MolecularFormulaTools.GetMolecularFormula(fragmentNL);
var fragmentMass = MolecularFormulaTools.GetMonoisotopicMass(fragmentMolFormula);
//skip this fragment which is lighter than the smallest peak
if (fragmentMass < minWeight)
{
continue;
}
//set bond energy
fragmentNL = setBondEnergy(fragment, fragmentNL, 500.0);
var props = fragmentNL.getProperties();
props.put("NeutralLossRule", MolecularFormulaTools.GetString(neutralLossFormula));
addFragmentToListMap(fragmentNL, MolecularFormulaTools.GetString(fragmentMolFormula));
//add to result list
ret.Add(fragmentNL);
}
//peak found....test another one
continue;
}
}
}
}
return ret;
}
