public void ModificationCollectionTest()
{
ModificationCollection a = new ModificationCollection(new OldSchoolModification(1, "Mod1"), new OldSchoolModification(2, "Mod2"));
double lala = 0;
IEnumerable aasdf = a;
foreach (var jadfk in aasdf)
{
lala += (jadfk as IHasMass).MonoisotopicMass;
}
Assert.AreEqual(3, lala);
Assert.AreEqual("Mod1 | Mod2", a.ToString());
a.Add(new OldSchoolModification(3, "Mod3"));
Assert.AreEqual("Mod1 | Mod2 | Mod3", a.ToString());
Assert.IsTrue(a.Contains(new OldSchoolModification(2, "Mod2")));
IHasMass[] myArray = new IHasMass[4];
a.CopyTo(myArray, 1);
Assert.AreEqual(3, myArray.Sum(b => b == null ? 0 : 1));
Assert.AreEqual(3, a.Count());
Assert.IsFalse(a.IsReadOnly);
a.Remove(new OldSchoolModification(2, "Mod2"));
Assert.AreEqual("Mod1 | Mod3", a.ToString());
double ok = 0;
foreach (var b in a)
{
ok += b.MonoisotopicMass;
}
Assert.AreEqual(4, ok);
a.Clear();
Assert.AreEqual("", a.ToString());
}
/// <summary>
/// Sets the modification at specific sites on this amino acid polymer
/// </summary>
/// <param name="modification">The modification to set</param>
/// <param name="sites">The sites to set the modification at</param>
/// <returns>The number of modifications added to this amino acid polymer</returns>
public virtual int SetModification(IHasMass modification, ModificationSites sites)
{
int count = 0;
if ((sites & ModificationSites.NPep) == ModificationSites.NPep)
{
NTerminusModification = modification;
count++;
}
for (int i = 0; i < Length; i++)
{
ModificationSites site = residues[i].Site;
if ((sites & site) == site)
{
ReplaceMod(i + 1, modification);
count++;
}
}
if ((sites & ModificationSites.PepC) == ModificationSites.PepC)
{
CTerminusModification = modification;
count++;
}
return(count);
}
public void TestNullArguments()
{
ChemicalFormula formulaA = new ChemicalFormula("CO");
IHasChemicalFormula ok = null;
Assert.AreEqual("item", Assert.Throws <ArgumentNullException>(() => { formulaA.Add(ok); }).ParamName);
ChemicalFormula ok2 = null;
Assert.AreEqual("formula", Assert.Throws <ArgumentNullException>(() => { formulaA.Add(ok2); }).ParamName);
Assert.AreEqual("other", Assert.Throws <ArgumentNullException>(() => { new ChemicalFormula(ok2); }).ParamName);
Element ok3 = null;
Assert.AreEqual("element", Assert.Throws <ArgumentNullException>(() => { formulaA.AddPrincipalIsotopesOf(ok3, 0); }).ParamName);
Assert.AreEqual("item", Assert.Throws <ArgumentNullException>(() => { formulaA.Remove(ok); }).ParamName);
Assert.AreEqual("formula", Assert.Throws <ArgumentNullException>(() => { formulaA.Remove(ok2); }).ParamName);
Assert.AreEqual("formula", Assert.Throws <ArgumentNullException>(() => { formulaA.IsSubsetOf(ok2); }).ParamName);
Assert.AreEqual("formula", Assert.Throws <ArgumentNullException>(() => { formulaA.IsSupersetOf(ok2); }).ParamName);
Assert.AreEqual("element", Assert.Throws <ArgumentNullException>(() => { formulaA.CountWithIsotopes(ok3); }).ParamName);
Assert.AreEqual("element", Assert.Throws <ArgumentNullException>(() => { formulaA.CountSpecificIsotopes(ok3, 0); }).ParamName);
Assert.IsFalse(formulaA.Equals(ok2));
IEnumerable <IHasChemicalFormula> ok4 = null;
Assert.AreEqual("formulas", Assert.Throws <ArgumentNullException>(() => { ChemicalFormula.Combine(ok4); }).ParamName);
Assert.AreEqual("element", Assert.Throws <ArgumentNullException>(() => { PeriodicTable.Add(ok3); }).ParamName);
Assert.AreEqual("formula", Assert.Throws <ArgumentNullException>(() => { new IsotopicDistribution(ok2); }).ParamName);
IHasMass ok5 = null;
Assert.AreEqual("objectWithMass", Assert.Throws <ArgumentNullException>(() => { ok5.ToMZ(0); }).ParamName);
var ok7 = new PhysicalObjectWithChemicalFormula("C");
}
/// <summary>
/// Replaces a modification (if present) at the specific index in the residue (0-based for N and C termini)
/// </summary>
/// <param name="index">The residue index to replace at</param>
/// <param name="mod">The modification to replace with</param>
private void ReplaceMod(int index, IHasMass mod)
{
// No error checking here as all validation will occur before this method is call. This is to prevent
// unneeded bounds checking
if (_modifications == null)
{
_modifications = new IHasMass[Length + 2];
}
IHasMass oldMod = _modifications[index]; // Get the mod at the index, if present
if (Equals(mod, oldMod))
{
return; // Same modifications, no change is required
}
if (oldMod != null)
{
MonoisotopicMass -= oldMod.MonoisotopicMass; // remove the old mod mass
}
_modifications[index] = mod;
if (mod != null)
{
MonoisotopicMass += mod.MonoisotopicMass; // add the new mod mass
}
}
/// <summary>
///
/// </summary>
/// <param name="mod"></param>
/// <param name="residueNumbers">(1-based) residue number</param>
public void SetModification(IHasMass mod, params int[] residueNumbers)
{
foreach (int residueNumber in residueNumbers)
{
SetModification(mod, residueNumber);
}
}
protected AminoAcidPolymer(AminoAcidPolymer aminoAcidPolymer, int firstResidue, int length, bool includeModifications)
{
Length = length;
residues = new Residue[length];
bool isNterm = firstResidue == 0;
bool isCterm = length + firstResidue == aminoAcidPolymer.Length;
_nTerminus = isNterm ? aminoAcidPolymer.NTerminus : new ChemicalFormulaTerminus(ChemicalFormula.ParseFormula("H"));
_cTerminus = isCterm ? aminoAcidPolymer.CTerminus : new ChemicalFormulaTerminus(ChemicalFormula.ParseFormula("OH"));
double monoMass = _nTerminus.MonoisotopicMass + _cTerminus.MonoisotopicMass;
Residue[] otherAminoAcids = aminoAcidPolymer.residues;
if (includeModifications && aminoAcidPolymer.ContainsModifications())
{
_modifications = new IHasMass[length + 2];
for (int i = 0; i < length; i++)
{
var aa = otherAminoAcids[i + firstResidue];
residues[i] = aa;
monoMass += aa.MonoisotopicMass;
IHasMass mod = aminoAcidPolymer._modifications[i + firstResidue + 1];
if (mod == null)
{
continue;
}
_modifications[i + 1] = mod;
monoMass += mod.MonoisotopicMass;
}
}
else
{
for (int i = 0, j = firstResidue; i < length; i++, j++)
{
var aa = otherAminoAcids[j];
residues[i] = aa;
monoMass += aa.MonoisotopicMass;
}
}
MonoisotopicMass = monoMass;
if (includeModifications)
{
if (isNterm)
{
NTerminusModification = aminoAcidPolymer.NTerminusModification;
}
if (isCterm)
{
CTerminusModification = aminoAcidPolymer.CTerminusModification;
}
}
}
/// <summary>
/// Calculates m/z value for a given mass assuming charge comes from losing or gaining protons
/// </summary>
public static double ToMZ(this IHasMass objectWithMass, int charge)
{
if (objectWithMass == null)
{
throw new ArgumentNullException("objectWithMass", "Cannot compute an MZ value for a null object");
}
return(ToMassToChargeRatio(objectWithMass.MonoisotopicMass, charge));
}
/// <summary>
/// Sets the modification at specific sites on this amino acid polymer
/// </summary>
/// <param name="modification">The modification to set</param>
/// <param name="residueNumber">The residue number to set the modification at</param>
public virtual void SetModification(IHasMass modification, int residueNumber)
{
if (residueNumber > Length || residueNumber < 1)
{
throw new MzLibException(string.Format(CultureInfo.InvariantCulture, "Residue number not in the correct range: [{0}-{1}] you specified: {2}", 1, Length, residueNumber));
}
ReplaceMod(residueNumber, modification);
}
/// <summary>
/// Sets the modification at the terminus of this amino acid polymer
/// </summary>
/// <param name="modification">The modification to set</param>
/// <param name="terminus">The termini to set the mod at</param>
public virtual void SetModification(IHasMass modification, Terminus terminus)
{
if ((terminus & Terminus.N) == Terminus.N)
{
NTerminusModification = modification;
}
if ((terminus & Terminus.C) == Terminus.C)
{
CTerminusModification = modification;
}
}
/// <summary>
/// Clears the modification set at the terminus of this amino acid polymer back
/// to the default C or N modifications.
/// </summary>
/// <param name="terminus">The termini to clear the mod at</param>
public void ClearModifications(Terminus terminus)
{
if ((terminus & Terminus.N) == Terminus.N)
{
NTerminusModification = null;
}
if ((terminus & Terminus.C) == Terminus.C)
{
CTerminusModification = null;
}
}
/// <summary>
/// Removes the specified mod from all locations on this polymer
/// </summary>
/// <param name="mod">The modification to remove from this polymer</param>
public void ClearModifications(IHasMass mod)
{
for (int i = 0; i <= Length + 1; i++)
{
if (!mod.Equals(_modifications[i]))
{
continue;
}
MonoisotopicMass -= mod.MonoisotopicMass;
_modifications[i] = null;
}
}
/// <summary>
/// Sets the modification at specific sites on this amino acid polymer
/// </summary>
/// <param name="modification">The modification to set</param>
/// <param name="residue">The residue to set the modification at</param>
/// <returns>The number of modifications added to this amino acid polymer</returns>
public virtual int SetModification(IHasMass modification, Residue residue)
{
int count = 0;
for (int i = 0; i < Length; i++)
{
if (!residue.Letter.Equals(residues[i].Letter))
{
continue;
}
ReplaceMod(i + 1, modification);
count++;
}
return(count);
}
/// <summary>
/// Adds the modification at the terminus of this amino acid polymer, combining modifications if a modification is already present
/// </summary>
/// <param name="modification">The modification to set</param>
/// <param name="terminus">The termini to set the mod at</param>
public virtual int AddModification(IHasMass modification, Terminus terminus)
{
IHasMass currentMod;
int count = 0;
if ((terminus & Terminus.N) == Terminus.N)
{
currentMod = NTerminusModification;
NTerminusModification = currentMod == null ? modification : new ModificationCollection(currentMod, modification);
count++;
}
if ((terminus & Terminus.C) == Terminus.C)
{
currentMod = CTerminusModification;
CTerminusModification = currentMod == null ? modification : new ModificationCollection(currentMod, modification);
count++;
}
return(count);
}
/// <summary>
/// Replaces all instances of the old modification with the new modification in this polymer
/// </summary>
/// <param name="oldMod">The modification to remove</param>
/// <param name="newMod">The modification to replace it with</param>
/// <returns>The number of modifications added to this amino acid polymer</returns>
public virtual int ReplaceModification(IHasMass oldMod, IHasMass newMod)
{
if (oldMod == null)
{
throw new MzLibException("Cannot replace a null modification");
}
int count = 0;
for (int i = 0; i < Length + 2; i++)
{
IHasMass mod = GetModification(i);
if (mod == null || !oldMod.Equals(mod))
{
continue;
}
ReplaceMod(i, newMod);
count++;
}
return(count);
}
public virtual int AddModification(IHasMass modification, ModificationSites sites)
{
if (_modifications == null)
{
_modifications = new IHasMass[Length + 2];
}
int count = 0;
IHasMass currentMod;
if ((sites & ModificationSites.NPep) == ModificationSites.NPep)
{
currentMod = NTerminusModification;
NTerminusModification = currentMod == null ? modification : new ModificationCollection(currentMod, modification);
count++;
}
for (int i = 0; i < Length; i++)
{
ModificationSites site = residues[i].Site;
if ((sites & site) == site)
{
currentMod = _modifications[i + 1];
ReplaceMod(i + 1, currentMod == null ? modification : new ModificationCollection(currentMod, modification));
count++;
}
}
if ((sites & ModificationSites.PepC) == ModificationSites.PepC)
{
currentMod = CTerminusModification;
CTerminusModification = currentMod == null ? modification : new ModificationCollection(currentMod, modification);
count++;
}
return(count);
}
public ChemicalProteoformHash(string hash, IHasMass hasMass)
{
Hash = hash;
_hasMass = hasMass;
}
/// <summary>
/// Calculates m/z value for a given mass assuming charge comes from losing or gaining protons
/// </summary>
public static double ToMz(this IHasMass objectWithMass, int charge)
{
return(ToMz(objectWithMass.MonoisotopicMass, charge));
}
/// <summary>
/// Adds the modification at specific sites on this amino acid polymer, combining modifications if a modification is already present
/// </summary>
/// <param name="modification">The modification to set</param>
/// <param name="location">The location to set the modification at</param>
public virtual void AddModification(IHasMass modification, int location)
{
IHasMass currentMod = GetModification(location);
ReplaceMod(location, currentMod == null ? modification : new ModificationCollection(currentMod, modification));
}
