private double GetTermMass(IonType type, ExplicitSequenceMods mods)
{
var modMasses = GetModMasses(mods);
switch (type)
{
case IonType.a: return _massDiffA + modMasses._massModCleaveN;
case IonType.b: return _massDiffB + modMasses._massModCleaveN;
case IonType.c: return _massDiffC + modMasses._massModCleaveN;
case IonType.x: return _massDiffX + modMasses._massModCleaveC;
case IonType.y: return _massDiffY + modMasses._massModCleaveC;
case IonType.z: return _massDiffZ + modMasses._massModCleaveC;
default:
throw new ArgumentException("Invalid ion type"); // Not L10N
}
}
public double GetPrecursorFragmentMass(string seq, ExplicitSequenceMods mods)
{
return GetFragmentMass(seq, IonType.precursor, seq.Length, null, 0, null, mods);
}
private double GetFragmentMass(string seq,
IonType type,
int ordinal,
int? decoyMassShift,
int massIndex,
IsotopeDistInfo isotopeDists,
ExplicitSequenceMods mods)
{
if (Transition.IsPrecursor(type))
{
if (isotopeDists != null)
{
int i = isotopeDists.MassIndexToPeakIndex(massIndex);
if (0 > i || i >= isotopeDists.CountPeaks)
{
throw new IndexOutOfRangeException(
string.Format(Resources.SequenceMassCalc_GetFragmentMass_Precursor_isotope__0__is_outside_the_isotope_distribution__1__to__2__,
GetMassIDescripion(massIndex), isotopeDists.PeakIndexToMassIndex(0),
isotopeDists.PeakIndexToMassIndex(isotopeDists.CountPeaks - 1)));
}
return isotopeDists.GetMassI(massIndex, decoyMassShift);
}
return GetPrecursorMass(seq, mods);
}
int len = seq.Length - 1;
bool nterm = Transition.IsNTerminal(type);
double mass = GetTermMass(nterm ? IonType.b : IonType.y, mods) + BioMassCalc.MassProton;
int iA = (nterm ? 0 : len);
int inc = (nterm ? 1 : -1);
var modMasses = GetModMasses(mods);
mass += (nterm ? modMasses._aminoNTermModMasses[seq[iA]] : modMasses._aminoCTermModMasses[seq[iA]]);
for (int i = 0; i < ordinal; i++)
{
char aa = seq[iA];
mass += _aminoMasses[aa] + modMasses._aminoModMasses[aa];
if (mods != null && iA < mods.ModMasses.Count)
mass += mods.ModMasses[iA];
iA += inc;
}
mass += GetTermDeltaMass(type); // Exactly match GetFragmentIonMasses()
return mass;
}
public double[,] GetFragmentIonMasses(string seq, ExplicitSequenceMods mods)
{
var modMasses = GetModMasses(mods);
int len = seq.Length - 1;
const int a = (int) IonType.a;
const int b = (int) IonType.b;
const int c = (int) IonType.c;
const int x = (int) IonType.x;
const int y = (int) IonType.y;
const int z = (int) IonType.z;
double nTermMassB = _massDiffB + modMasses._massModCleaveN + BioMassCalc.MassProton;
double deltaA = _massDiffA - _massDiffB;
double deltaC = _massDiffC - _massDiffB;
double cTermMassY = _massDiffY + modMasses._massModCleaveC + BioMassCalc.MassProton;
double deltaX = _massDiffX - _massDiffY;
double deltaZ = _massDiffZ - _massDiffY;
double[,] masses = new double[z + 1, len];
int iN = 0, iC = len;
nTermMassB += modMasses._aminoNTermModMasses[seq[iN]];
cTermMassY += modMasses._aminoCTermModMasses[seq[iC]];
while (iC > 0)
{
char aa = seq[iN];
nTermMassB += _aminoMasses[aa] + modMasses._aminoModMasses[aa];
if (mods != null && iN < mods.ModMasses.Count)
nTermMassB += mods.ModMasses[iN];
masses[a, iN] = nTermMassB + deltaA;
masses[b, iN] = nTermMassB;
masses[c, iN] = nTermMassB + deltaC;
iN++;
aa = seq[iC];
cTermMassY += _aminoMasses[aa] + modMasses._aminoModMasses[aa];
if (mods != null && iC < mods.ModMasses.Count)
cTermMassY += mods.ModMasses[iC];
iC--;
masses[x, iC] = cTermMassY + deltaX;
masses[y, iC] = cTermMassY;
masses[z, iC] = cTermMassY + deltaZ;
}
return masses;
}
public double GetFragmentMass(Transition transition, IsotopeDistInfo isotopeDist, ExplicitSequenceMods mods)
{
if (transition.IsCustom())
{
var type = transition.IonType;
var massIndex = transition.MassIndex;
if (Transition.IsPrecursor(type) && (isotopeDist != null))
{
var i = isotopeDist.MassIndexToPeakIndex(massIndex);
if (0 > i || i >= isotopeDist.CountPeaks)
{
throw new IndexOutOfRangeException(
string.Format(Resources.SequenceMassCalc_GetFragmentMass_Precursor_isotope__0__is_outside_the_isotope_distribution__1__to__2__,
GetMassIDescripion(massIndex), isotopeDist.PeakIndexToMassIndex(0),
isotopeDist.PeakIndexToMassIndex(isotopeDist.CountPeaks - 1)));
}
return isotopeDist.GetMassI(massIndex);
}
return (MassType == MassType.Average)
? transition.CustomIon.AverageMass
: transition.CustomIon.MonoisotopicMass;
}
return GetFragmentMass(transition.Group.Peptide.Sequence,
transition.IonType,
transition.Ordinal,
transition.DecoyMassShift,
transition.MassIndex,
isotopeDist,
mods);
}
private ModMasses GetModMasses(ExplicitSequenceMods mods)
{
// If there are explicit modifications and this is a heavy mass
// calculator, then use only the heavy masses without the static
// masses added in.
if (mods != null && !mods.RequiresAllCalcMods && _modMassesHeavy != null)
return _modMassesHeavy;
return _modMasses;
}
public double GetPrecursorMass(string seq, ExplicitSequenceMods mods)
{
var modMasses = GetModMasses(mods);
double mass = _massCleaveN + modMasses._massModCleaveN +
_massCleaveC + modMasses._massModCleaveC + BioMassCalc.MassProton;
// Add any amino acid terminal specific modifications
int len = seq.Length;
if (len > 0)
mass += modMasses._aminoNTermModMasses[seq[0]];
if (len > 1)
mass += modMasses._aminoCTermModMasses[seq[len - 1]];
// Add masses of amino acids
for (int i = 0; i < len; i++)
{
char c = seq[i];
mass += _aminoMasses[c] + modMasses._aminoModMasses[c];
if (mods != null && i < mods.ModMasses.Count)
mass += mods.ModMasses[i];
}
return mass;
}
/// <summary>
/// Convert a charged peptide to a small molecule ion formula
/// </summary>
public string GetIonFormula(string seq, int charge, ExplicitSequenceMods mods)
{
double unexplainedMass;
var molecule = GetFormula(seq, mods, out unexplainedMass);
if (unexplainedMass != 0.0)
throw new ArgumentException("Unexplained mass when deriving ion formula from sequence "+seq); // Not L10N
int chargeStep = (charge > 0) ? 1 : -1; // Negative charge on a peptide is not a real world concern, but useful for test purposes
for (int z = 0; z < Math.Abs(charge); z++)
molecule = molecule.SetElementCount("H", molecule.GetElementCount("H") + chargeStep); // Not L10N
return molecule.ToString();
}
private Molecule GetFormula(string seq, ExplicitSequenceMods mods, out double unexplainedMass)
{
var formula = new FormulaBuilder(_massCalc);
var modMasses = GetModMasses(mods);
formula.Append(modMasses._massModCleaveNFormula, modMasses._massModCleaveNExtra);
formula.Append(modMasses._massModCleaveCFormula, modMasses._massModCleaveCExtra);
for (int i = 0, len = seq.Length; i < len; i++)
{
char c = seq[i];
formula.Append(AMINO_FORMULAS[c])
.Append(modMasses._aminoModFormulas[c], modMasses._aminoModMassesExtra[c]);
// Terminal modifications
if (i == 0)
formula.Append(modMasses._aminoNTermModFormulas[c], modMasses._aminoNTermModMassesExtra[c]);
else if (i == len - 1)
formula.Append(modMasses._aminoCTermModFormulas[c], modMasses._aminoCTermModMassesExtra[c]);
}
if (mods != null)
{
foreach (ExplicitMod mod in mods.AllMods)
{
double modUnexplainedMass;
string modFormula = GetModFormula(seq[mod.IndexAA], mod.Modification, out modUnexplainedMass);
formula.Append(modFormula, modUnexplainedMass);
}
}
formula.Append("H2O"); // N-term = H, C-term = OH // Not L10N
unexplainedMass = formula.UnexplainedMass;
// CONSIDER: More efficient translation between builder and Molecure.
// Both contain a dictionary for atom counts.
return Molecule.Parse(formula.ToString());
}
public MassDistribution GetMzDistribution(string seq, int charge, IsotopeAbundances abundances, ExplicitSequenceMods mods)
{
double unexplainedMass;
Molecule molecule = GetFormula(seq, mods, out unexplainedMass);
return GetMzDistribution(molecule, charge, abundances, unexplainedMass, true);
}
public double GetAAModMass(char aa, int seqIndex, int seqLength, ExplicitSequenceMods mods)
{
var modMasses = GetModMasses(mods);
double mod = modMasses._aminoModMasses[aa];
// Explicit modifications
if (mods != null && seqIndex < mods.ModMasses.Count)
mod += mods.ModMasses[seqIndex];
// Terminal modifications
if (seqIndex == 0)
mod += modMasses._massModCleaveN + modMasses._aminoNTermModMasses[aa];
else if (seqIndex == seqLength - 1)
mod += modMasses._massModCleaveC + modMasses._aminoCTermModMasses[aa];
return mod;
}
public string GetModifiedSequence(string seq, ExplicitSequenceMods mods, SequenceModFormatType format, bool useExplicitModsOnly)
{
// If no modifications, do nothing
if (!IsModified(seq) && mods == null)
return seq;
// Otherwise, build a modified sequence string like AMC[+57.0]LP[-37.1]K
StringBuilder sb = new StringBuilder();
for (int i = 0, len = seq.Length; i < len; i++)
{
char c = seq[i];
var modMass = GetAAModMass(c, i, len, mods);
sb.Append(c);
if (modMass != 0)
{
StaticMod mod = mods != null ? mods.FindFirstMod(i) : null;
if (mod == null && useExplicitModsOnly)
continue;
sb.Append(GetModDiffDescription(modMass, mod, format));
}
}
return sb.ToString();
}
public string GetModifiedSequence(string seq, ExplicitSequenceMods mods, bool formatNarrow)
{
var format = formatNarrow ? SequenceModFormatType.mass_diff_narrow : SequenceModFormatType.mass_diff;
return GetModifiedSequence(seq, mods, format, false);
}
public ExplicitSequenceMassCalc(ExplicitMods mods, SequenceMassCalc massCalcBase, IsotopeLabelType labelType)
{
_massCalcBase = massCalcBase;
_mods = new ExplicitSequenceMods
{
Mods = mods.GetModifications(labelType),
StaticBaseMods = mods.GetStaticBaseMods(labelType),
ModMasses = mods.GetModMasses(_massCalcBase.MassType, labelType),
RequiresAllCalcMods = mods.IsVariableStaticMods
};
}
