/// <summary>
/// Get the orignal scan ID.
/// </summary>
/// <param name="scanMS2">The spectrum.</param>
/// <returns>The spectrum with the original scan ID.</returns>
private static XTSpectrum GetOriginalScanID(XTSpectrum scanMS2)
{
int orgID = int.Parse(scanMS2.SpectrumDescription.Split(';').First().Split(' ').Last());
scanMS2.ID = orgID;
return(scanMS2);
}
/// <summary>
/// Calculate the spectrum ions.
/// </summary>
/// <param name="scanMS2">The spectrum.</param>
/// <returns></returns>
internal static XTSpectrum CalcSpecIons(XTSpectrum scanMS2)
{
// Get all of the amino acids as a char array
char[] aaSeq = scanMS2.Proteins[0].DoaminSeq.ToCharArray();
// Convert the char array to a string array
string[] aaSeqArray = aaSeq.Select(a => a.ToString()).ToArray();
// Set the string array to the spectrum's amino acid sequence
scanMS2.SpectrumAminoAcidSequence = aaSeqArray;
// Create a temporary list of amino acid masses
var aaMasses = new List <double>();
// Loop through all of the amino acid sequence
foreach (string aa in aaSeqArray)
{
// Try to get the amino acid mass
if (massDictAminoAcids.TryGetValue(aa, out double aaMass))
{
// If possible, add the mass to the list of amino acid masses
aaMasses.Add(aaMass);
}
}
// Set the mass array to the array of spectrum's amino acid sequence masses
scanMS2.SpectrumAaMasses = aaMasses.ToArray();
return(scanMS2);
}
/// <summary>
/// Add the info for a potential citrullination.
/// </summary>
/// <param name="index">The index of the potential citrullination.</param>
private void AddPotCitInfo(int index)
{
// Set the parent mass
double pMass = 1.007276470;
// Get the spectrum
XTSpectrum argSpec = valKVP.Key;
// Get the scan
RawScan potCitScan = valKVP.Value[index];
string scanIDProtein = string.Format("{0} / {1}", potCitScan.ScanNumber, argSpec.SpectrumLabel.Split('|')[1]);
// Set the scan id
metroLabelCitID.Text = scanIDProtein;
// Set the parent mass
metroLabelCitPMass.Text = Math.Round((potCitScan.PreCursorMz * potCitScan.Charge) - ((potCitScan.Charge - 1) * pMass), 3).ToString();
// Set the charge
metroLabelCitCharge.Text = potCitScan.Charge.ToString();
// Set the sequence
metroLabelCitSeq.Text = string.Format("({0})", argSpec.Proteins[0].DoaminSeq);
// Set the retention time for the arginine spectrum
metroLabelCitRTime.Text = string.Format("{0} sec.", potCitScan.RetentionTime);
// Set the retention time for the MS1 Serie spectrum
metroLabelPotCitMS1RTime.Text = string.Format("{0} sec.", potCitScan.RetentionTime);
// Set the filename
metroLabelPotCitFileName.Text = potCitScan.OriginalFileName.Split('.')[0];
// Set the scores
metroLabelCitScore.Text = potCitScan.CitScore.ToString();
metroLabelMatchScore.Text = potCitScan.MatchScore.ToString();
}
/// <summary>
/// Find the possible Y-ions.
/// </summary>
/// <param name="scanMS2">The spectrum</param>
/// <returns>The spectrum with the possible Y-ions.</returns>
internal static XTSpectrum FindPossibleYIons(XTSpectrum scanMS2)
{
// Set the proton, hydrogen and oxygen mass and calculate the mass for the hydroxyl-group
double pMass = 1.007276470;
double hMass = 1.007825035;
double oMass = 15.994914630;
double ohMass = hMass + oMass;
// Reverse the amino acid masses
var aaMasses = scanMS2.SpectrumAaMasses.Reverse().ToArray();
// Create a temporary list of B-ions
List <double> yIons = new List <double>();
// The temporary variable for the y-ion
double yIon = 0;
// Loop through all of the amino acid. TODO: Reformat so same code for much as possible
for (int i = 0; i <= aaMasses.Length - 1; i++)
{
// Try to get the modification mass and add it to the y-ion.
if (scanMS2.SpectrumYIonModDict.TryGetValue(i, out double modMass))
{
yIon += modMass;
}
// Add the amino acid mass and the mass qnd the mass of the proton, hydrogen and hydroxyl-group to the y-ion+
double extraMass = (i == 0) ? (ohMass + hMass + pMass) : 0;
yIon += aaMasses[i] + extraMass;
// Add the y-ion value to the list
yIons.Add(yIon);
}
// Set the array of y-ions to spectrum's possible y-ions
scanMS2.SpectrumPossibleYIons = yIons.ToArray();
// Return the spectrum
return(scanMS2);
}
/// <summary>
/// Score the main citrullinated spectrum.
/// </summary>
/// <param name="spectrum">The spectrum to be scored.</param>
/// <returns></returns>
private static XTSpectrum ScoreCitMainSpectrum(XTSpectrum spectrum)
{
// The main spectrum does not have a match score
spectrum.MatchScore = 0;
// Validate the fragmentation.
if (ValidateSpectrumFragmentation(spectrum, spectrum.SpectrumAminoAcidSequence) == false)
{
// If the fragmentation is invalid, set CitScore to 0 and return spectrum
spectrum.CitScore = 0;
spectrum.IsoCyanicLossMzMs2 = new double[0];
return(spectrum);
}
// Calculate the score
double citScore = IsIsoCyanicAcidLossPresentMs1(spectrum) ? ScoreSettings.MS1IsoCyanicLossScore : 0;
citScore += CountIsoCyanicAcidLossPresentMs2(spectrum) * 1;
citScore += -Math.Log10(spectrum.SpectrumEVal);
// Set the score
spectrum.CitScore = Math.Round(citScore, 1);
// Return the scored spectrum
return(spectrum);
}
/// <summary>
/// Find the possible B-ions.
/// </summary>
/// <param name="scanMS2">The spectrum</param>
/// <returns>The spectrum with the possible B-ions.</returns>
internal static XTSpectrum FindPossibleBIons(XTSpectrum scanMS2)
{
// Set the proton masses
double pMass = 1.007276470;
// Create a temporary list of B-ions
List <double> bIons = new List <double>();
// The temporary variable for the b-ion
double bIon = 0;
// Loop through all of the amino acid. TODO: Reformat so same code for much as possible
for (int i = 0; i <= scanMS2.SpectrumAaMasses.Length - 1; i++)
{
// Try to get the modification mass and add it to the b-ion.
if (scanMS2.SpectrumBIonModDict.TryGetValue(i, out double modMass))
{
bIon += modMass;
}
// Add the amino acid mass and the mass qnd the mass of the proton to the b-ion
double extraMass = (i == 0) ? pMass : 0;
bIon += scanMS2.SpectrumAaMasses[i] + extraMass;
// Add the b-ion value to the list
bIons.Add(bIon);
}
// Set the array of b-ions to spectrum's possible b-ions
scanMS2.SpectrumPossibleBIons = bIons.ToArray();
// Return the spectrum
return(scanMS2);
}
/// <summary>
/// Score the lone citrullinated spectra.
/// </summary>
/// <param name="inputSpectra">>The list with the citrullinated spectra to be scored.</param>
/// <returns>The list of scored spectra.</returns>
internal static List <XTSpectrum> ScoreLoneCitrullinationSpectra(List <XTSpectrum> inputSpectra)
{
// Create a temporary list of scored spectra
List <XTSpectrum> scoredSpectra = new List <XTSpectrum>();
// Loop through all of the spectra
foreach (XTSpectrum spectrum in inputSpectra)
{
// Score the spectrum
XTSpectrum scoredSpectrum = ScoreCitMainSpectrum(spectrum);
// Add it to the list of scored spectra
scoredSpectra.Add(scoredSpectrum);
}
// Sort the scored spectra after its score
var scoredSpectraSorted = (from x in scoredSpectra
orderby x.MatchScore descending
select x).ToList();
// Add spectra above cut-off if set to do so.
if (ScoreSettings.IncludeCutOff)
{
// Add to quantification
AddLoneCitSpectraAboveCutoffToQunatification(scoredSpectraSorted);
}
// Return the list of scored spectra
return(scoredSpectraSorted);
}
/// <summary>
/// Add the arginine information.
/// </summary>
/// <param name="index">The index of the scan.</param>
private void AddArgInfo(int index)
{
// Get the spectrum
XTSpectrum argSpec = valKVP.Value[index];
string scanIDProtein = string.Format("{0} / {1}", argSpec.ID, argSpec.SpectrumLabel.Split('|')[1]);
// Set the scan id
metroLabelArgID.Text = scanIDProtein;
// Set the parent mass
metroLabelArgPMass.Text = Math.Round(argSpec.ParentMass, 3).ToString();
// Set the charge
metroLabelArgCharge.Text = argSpec.ParentIonCharge.ToString();
// Set the sequence
metroLabelArgSeq.Text = argSpec.Proteins[0].DoaminSeq;
// Set the spectrum e-value
metroLabelArgEval.Text = argSpec.SpectrumEVal.ToString();
// Set the retention time for the arginine spectrum
metroLabelArgRTime.Text = string.Format("{0} sec.", argSpec.RetentionTime);
// Set the retention time for the MS1 citrullinated spectrum
metroLabelArgMS1RTime.Text = string.Format("{0} sec.", argSpec.ParentScan.RetentionTime);
// Set the filename
metroLabelArgFileName.Text = argSpec.OriginalFileName.Split('.')[0];;
// Set the score:
metroLabelMatchScore.Text = argSpec.MatchScore.ToString();
}
/// <summary>
/// Add the citrullination information.
/// </summary>
private void AddCitInfo()
{
// Get the spectrum
XTSpectrum citSpec = valKVP.Key;
// Get and set the scan id and protein
string scanIDProtein = string.Format("{0} / {1}", citSpec.ID, citSpec.SpectrumLabel.Split('|')[1]);
metroLabelCitID.Text = scanIDProtein;
// Set the parent mass
metroLabelCitPMass.Text = Math.Round(citSpec.ParentMass, 3).ToString();
// Set the charge
metroLabelCitCharge.Text = citSpec.ParentIonCharge.ToString();
// Set the sequence
metroLabelCitSeq.Text = citSpec.Proteins[0].DoaminSeq;
// Set the spectrum e-value
metroLabelCitEval.Text = citSpec.SpectrumEVal.ToString();
// Set the retention time
metroLabelCitRTime.Text = string.Format("{0} sec.", citSpec.RetentionTime);
// Set the retention time
metroLabelCitMS1RTime.Text = string.Format("{0} sec.", citSpec.ParentScan.RetentionTime);
// Set the filename
metroLabelCitFileName.Text = citSpec.OriginalFileName.Split('.')[0];;
// Set the CitScore
metroLabelCitScore.Text = citSpec.CitScore.ToString();
}
/// <summary>
/// Calculate CitScore and MatchScore for the complementary cit scan.
/// </summary>
/// <param name="mainArgSpectrum">The main arginine spectrum.</param>
/// <param name="complCitScan">The complementary cit scan.</param>
/// <returns>The scored scan.</returns>
private static RawScan ScoreCitComplSpectrum(XTSpectrum mainArgSpectrum, RawScan complCitScan)
{
double citScore;
//Validate the fragmentation.
if (ValidateSpectrumFragmentation(complCitScan, mainArgSpectrum.SpectrumAminoAcidSequence))
{
// Calculate CitScore
citScore = IsIsoCyanicAcidLossPresentMs1(complCitScan) ? 10 : 0;
//citScore += CountIsoCyanicAcidLossPresentMs2(mainArgSpectrum, complCitScan) * 1;
citScore = -Math.Log10(0.05);
citScore += CountIsoCyanicAcidLossPresentMs2(complCitScan, GetIndexOfCitrullinationFromArg(mainArgSpectrum), mainArgSpectrum.SpectrumAminoAcidSequence);
}
else
{
// If the fragmentation is invalid, set CitScore to 0
citScore = 0;
complCitScan.IsoCyanicLossMzMs2 = new double[0];
}
// Set the CitScore
complCitScan.CitScore = Math.Round(citScore, 1);
// Score match between spectra
complCitScan = ScoreMatchMainArgComplCit(mainArgSpectrum, complCitScan);
// Return spectra
return(complCitScan);
}
/// <summary>
/// Find the original MS1 information such as retention time, orgininal scan number and the parent MS1 scan.
/// </summary>
/// <param name="spectrumMS2">The MS2 spectrum.</param>
/// <returns>The MS2 spectrum with the MS1 data.</returns>
internal static XTSpectrum FindOriginalMS1Info(XTSpectrum spectrumMS2)
{
// Get the scan number
string description = spectrumMS2.SpectrumDescription;
int scanNumb = int.Parse(description.Split(';').First().Split(' ').Last());
// Loop through each of the input files
foreach (Input input in FileReader.inputFiles)
{
// Get the input file name
string inputFileName = input.FilePath.Split('\\').Last();
// Check if the original filename matches the name of the input file
if (spectrumMS2.OriginalFileName == inputFileName)
{
// If the filename matches the input filename
// Loop through all of the MS2 scans in the input
foreach (RawScan scan in input.MS2Scans)
{
// Check if the scan number matches the scan number of the MS2 spectrum
if (scanNumb == scan.ScanNumber)
{
// If so.
// Set the retention time
spectrumMS2.RetentionTime = scan.RetentionTime;
// Set the parent scan number
spectrumMS2.ParentScanNumber = scan.ParentScanNumber;
// Set the precursor MZ-value
spectrumMS2.PreCursorMz = scan.PreCursorMz;
}
}
// Loop through each of the MS1 scans
foreach (RawScan s in input.MS1Scans)
{
// Check if the MS2 spectrum parent scan number matches the MS1 scan
if (spectrumMS2.ParentScanNumber == s.ScanNumber)
{
// If so
// Set the parent scan
spectrumMS2.ParentScan = s;
// Set it to be an non-orphan
spectrumMS2.Orphan = false;
// Break and continue with the next scan
break;
}
else
{
// If not
// Set the scan to be an orphan
spectrumMS2.Orphan = true;
}
}
}
}
// Return the spectrum with the new information
return(spectrumMS2);
}
/// <summary>
/// Add the arginine spectra to the quantififcation dictionary.
/// </summary>
/// <param name="argSpec">The arginine spectra.</param>
/// <param name="citScan">The citrullinated scan.</param>
/// <returns>The dictionary containing the new spectra.</returns>
internal static Dictionary <XTSpectrum, RawScan> AddTokvpArgSpecScanDict(XTSpectrum argSpec, RawScan citScan)
{
if (argSpecScanDict.ContainsKey(argSpec) == false)
{
argSpecScanDict.Add(argSpec, citScan);
}
return(argSpecScanDict);
}
/// <summary>
/// Add the citrullinated spectra to the quantififcation dictionary.
/// </summary>
/// <param name="citSpec">The citrullinated spectra.</param>
/// <param name="argSpec">The arginine spectra.</param>
/// <returns>The dictionary containing the new spectra.</returns>
internal static Dictionary <XTSpectrum, XTSpectrum> AddTokvpCitSpecSpecDict(XTSpectrum citSpec, XTSpectrum argSpec)
{
if (citSpecSpecDict.ContainsKey(citSpec) == false)
{
citSpecSpecDict.Add(citSpec, argSpec);
}
return(citSpecSpecDict);
}
/// <summary>
/// Find citrullinated spectra.
/// </summary>
internal static void FindCitrullinatedSpectra()
{
// Create an empty list of validation results
var vResultList = new List <ValResult>();
// Set the search parameters. Amino acid and mass change
string residue = "R";
double mChange = 0.984;
// Loop through the list of X!Tandem search results
foreach (XTResult res in FileReader.XTandemSearchResults)
{
// Create an empty instance of validation result
ValResult vResult = new ValResult();
// Create a empty list of spectra
var specModPeptides = new List <XTSpectrum>();
// Set the current X!Tandem result as the parent result of the validation result
vResult.ParentResult = res;
// Loop through each of the spectra in the result
foreach (XTSpectrum spec in res.XSpectrums)
{
// Loop through each of the proteins in the spectrum
foreach (XTProtein prot in spec.Proteins)
{
// Loop through each of the modification in the protein
foreach (XTModification mod in prot.Modifications)
{
// Check that the modification matches the citrullination
if (mod.AminoAcid == residue & mod.MassChange == mChange)
{
// If so.
// Calculate the ions
XTSpectrum scanMS2 = IonCalculation.CalculateAllIons(spec);
// Get the original filename
scanMS2 = ReturnOriginalFileNameSpectrum(scanMS2, vResult);
// Get the original scan ID
scanMS2 = GetOriginalScanID(scanMS2);
// Find the original MS1 informaton
scanMS2 = FindMS1.FindOriginalMS1Info(scanMS2);
// Handle orphan spectra
scanMS2 = FindMS1.HandleOrphanSpecs(scanMS2);
// Add the spectra to the list of modified spectra
specModPeptides.Add(scanMS2);
}
}
}
}
// Set the modified spectra to the temporary list filled with data
vResult.ModifiedSpectra = specModPeptides;
// Add the result to the result list
vResultList.Add(vResult);
}
// Set the result
ReturnVResultCit(vResultList);
}
/// <summary>
/// Add the spectrum to quantification.
/// </summary>
private void MetroButtonAddQuant_Click(object sender, EventArgs e)
{
// Get the spectrum
XTSpectrum spectrumCit = valSpec;
// Add the spectrum to the dictionary
Quantification.AddToLoneCitSpecList(spectrumCit);
// Update the quantification id list
UpdateChosenForQuant(valSpec.ID, true);
// Enable and disable the button
metroButtonAddQuant.Enabled = false;
metroButtonRemoveQuant.Enabled = true;
}
/// <summary>
/// Add the citrullination information.
/// </summary>
private void AddCitInfo()
{
XTSpectrum citSpec = valSpec;
metroLabelID.Text = citSpec.ID.ToString();
metroLabelCitPMass.Text = Math.Round(citSpec.ParentMass, 3).ToString();
metroLabelCitCharge.Text = citSpec.ParentIonCharge.ToString();
metroLabelCitSeq.Text = citSpec.Proteins[0].DoaminSeq;
metroLabelCitEval.Text = citSpec.SpectrumEVal.ToString();
metroLabelCitRTime.Text = string.Format("{0} sec.", citSpec.RetentionTime);
metroLabelCitMS1RTime.Text = string.Format("{0} sec.", citSpec.ParentScan.RetentionTime);
metroLabelCitFileName.Text = citSpec.OriginalFileName.Split('.')[0];
metroLabelCitScore.Text = citSpec.CitScore.ToString();
}
/// <summary>
/// Get the index of the citrullination in a citrullinated spectrum.
/// </summary>
/// <param name="spectrum">The spectrum.</param>
/// <returns>The index of the citrullination.</returns>
private static int GetIndexOfCitrullination(XTSpectrum spectrum)
{
// Loop trough all of the modifications in the spectrum
foreach (KeyValuePair <int, double> mod in spectrum.SpectrumBIonModDict)
{
// Check that the modification mass change equals the citrullination. If it does, return the key
if (mod.Value == 0.984)
{
return(mod.Key);
}
}
// If no citrullinations was found, return -1
return(-1);
}
/// <summary>
/// Score the Citrullinated spectra.
/// </summary>
/// <param name="inputSpectra">The dictionary with the citrullinated spectra to be scored and their complementary arginine spectra.</param>
/// <returns>The dictionary with the scored citrullinated spectra an their complementary scored arginine spectra.</returns>
internal static Dictionary <XTSpectrum, List <XTSpectrum> > ScoreCitrullinationSpectra(Dictionary <XTSpectrum, List <XTSpectrum> > inputSpectra)
{
// Create a temporary list of scored spectra.
Dictionary <XTSpectrum, List <XTSpectrum> > scoredSpectra = new Dictionary <XTSpectrum, List <XTSpectrum> >();
// Loop through all of the spectra keyvaluepairs.
foreach (KeyValuePair <XTSpectrum, List <XTSpectrum> > spectrum in inputSpectra)
{
// Score the main spectrum
XTSpectrum scoredSpectrum = ScoreCitMainSpectrum(spectrum.Key);
// Score all of the complementary spectra
// Create a temporary list of scored complementary spectra
List <XTSpectrum> scoredComplSpectra = new List <XTSpectrum>();
// Loop through all of the complementary spectra
foreach (XTSpectrum complSpectrum in spectrum.Value)
{
// Score the complementary spectrum
XTSpectrum scoredComplSpectrum = ScoreMatchMainCitComplArg(scoredSpectrum, complSpectrum);
scoredComplSpectrum.IsoCyanicLossMzMs2 = new double[0];
// Add the scored spectrum to the list
scoredComplSpectra.Add(scoredComplSpectrum);
}
// Sort the list
var scoredCompSpectraSorted = from x in scoredComplSpectra
orderby x.MatchScore descending
select x;
scoredComplSpectra = scoredCompSpectraSorted.ToList();
// Add the main spectrum and the complementary spectra to the dictionary
scoredSpectra.Add(scoredSpectrum, scoredComplSpectra);
}
var sortedScoredSpectra = (from x in scoredSpectra
orderby x.Key.CitScore descending
select x).ToDictionary(x => x.Key, x => x.Value);
// Add spectra above cut-off if set to do so.
if (ScoreSettings.IncludeCutOff)
{
// Add to quantification
AddCitSpectraAboveCutoffToQuantification(sortedScoredSpectra);
}
// Return the sorted scored spectra
return(sortedScoredSpectra);
}
/// <summary>
/// Add the spectrum to quantification.
/// </summary>
private void MetroButtonAddQuant_Click(object sender, EventArgs e)
{
// Get the spectra
XTSpectrum spectrumCit = valKVP.Key;
XTSpectrum spectrumArg = valKVP.Value[argIndex];
// Add the spectrum to the dictionary
Quantification.AddTokvpCitSpecSpecDict(spectrumCit, spectrumArg);
// Update the quantification id list
UpdateChosenForQuant(valKVP.Key.ID, true);
// Prevent moving back and forth through the complementary spectra
metroButtonNextArgScan.Enabled = false;
metroButtonPrevArgScan.Enabled = false;
// Enable and disable the button
metroButtonAddQuant.Enabled = false;
metroButtonRemoveQuant.Enabled = true;
}
/// <summary>
/// Score the arginine spectra.
/// </summary>
/// <param name="inputSpectra">The dictionary with the arginine spectra to be scored and their complementary citrullinated spectra.</param>
/// <returns>he dictionary with the scored spectra an their complementary citrullinated spectra.</returns>
internal static Dictionary <XTSpectrum, List <RawScan> > ScoreArginineSpectra(Dictionary <XTSpectrum, List <RawScan> > inputSpectra)
{
// Create a temporary dictionary of scored spectra
Dictionary <XTSpectrum, List <RawScan> > scoredSpectra = new Dictionary <XTSpectrum, List <RawScan> >();
// Loop throguh all of the spectra keyvaluepairs
foreach (KeyValuePair <XTSpectrum, List <RawScan> > spectrum in inputSpectra)
{
// Get the arginine spectrum and set the array of isocyanic loss m/z in order to prevent error
XTSpectrum argSpectrum = spectrum.Key;
argSpectrum.IsoCyanicLossMzMs2 = new double[0];
List <RawScan> scoredCompCitScans = new List <RawScan>();
// Loop trough all of the complementary cit spectra
foreach (RawScan citScan in spectrum.Value)
{
// Calculate the score
RawScan scoredScan = ScoreCitComplSpectrum(argSpectrum, citScan);
// Add the score to the list of cit scans
scoredCompCitScans.Add(scoredScan);
}
// Sort the list
var scoredCompSpectraSorted = from x in scoredCompCitScans
orderby x.MatchScore descending
select x;
scoredCompCitScans = scoredCompSpectraSorted.ToList();
scoredSpectra.Add(argSpectrum, scoredCompCitScans);
}
// Sort dictionary
var sortedScoredSpectra = (from x in scoredSpectra
orderby x.Key.CitScore descending
select x).ToDictionary(x => x.Key, x => x.Value);
// Add spectra above cut-off if set to do so.
if (ScoreSettings.IncludeCutOff)
{
// Add to quantification
AddArgSpectraAboveCutOffToQuantification(sortedScoredSpectra);
}
// Return the sorted scored spectra
return(sortedScoredSpectra);
}
/// <summary>
/// Add the next arginine MS1 series to the chart.
/// </summary>
/// <param name="scanMS2">The MS2 spectrum.</param>
private void AddNextArgMS1Series(XTSpectrum scanMS2)
{
//Removes old series:
chartArgMS1.Series.Remove(chartArgMS1.Series["Serie"]);
//Add Data:
chartArgMS1.Series.Add("Serie");
chartArgMS1.Series["Serie"].ChartType = SeriesChartType.StackedColumn;
chartArgMS1.Series["Serie"].AxisLabel = "m/z";
chartArgMS1.Series["Serie"]["PixelPointWidth"] = "2";
double[] mzVals = scanMS2.ParentScan.MzValues;
double[] intVals = scanMS2.ParentScan.Intencities;
for (int i = 0; i <= mzVals.Length - 1; i++)
{
chartArgMS1.Series["Serie"].Points.AddXY(mzVals[i], intVals[i]);
}
chartArgMS1.Series["Serie"].ChartArea = "ChartArea";
chartArgMS1.Legends.Clear();
double tolerance = 0.05;
double ms2PrecursorMzVal = scanMS2.PreCursorMz;
for (int i = 0; i <= chartArgMS1.Series["Serie"].Points.Count() - 1; i++)
{
double error = Math.Abs(chartArgMS1.Series["Serie"].Points[i].XValue - ms2PrecursorMzVal);
if (error <= tolerance)
{
chartArgMS1.Series["Serie"].Points[i].Color = Color.Blue;
}
}
//Add X-Axis Maximum to chart:
int xAxisMax = (int)Math.Ceiling(mzVals.Last() / 100) * 100;
chartArgMS1.ChartAreas["ChartArea"].AxisX.Maximum = xAxisMax;
//Make Custom Labels for X-Axis, interval 100:
int endIndex = xAxisMax / 100;
for (int i = 1; i <= endIndex; i++)
{
int index = i * 100;
chartArgMS1.ChartAreas["ChartArea"].AxisX.CustomLabels.Add(index - 25, index + 25, string.Format("{0}", index), 2, LabelMarkStyle.None, GridTickTypes.TickMark);
}
}
/// <summary>
/// Check what state the quantificaation buttons should be in.
/// </summary>
/// <param name="spec">The spectrum.</param>
private void EnableQuantButtons(XTSpectrum spec)
{
// Check if the quantification list contains the spectrum.
if (Validation.loneCitChosenForQuantList.Contains(spec.ID))
{
// If so, disable the add button
metroButtonAddQuant.Enabled = false;
// Enable the remove button
metroButtonRemoveQuant.Enabled = true;
}
else
{
// If not, enable the add button
metroButtonAddQuant.Enabled = true;
// Disable the remove button
metroButtonRemoveQuant.Enabled = false;
}
}
/// <summary>
/// Calculate all of the ions in the spectrum.
/// </summary>
/// <param name="scanMS2">The MS2 spectrum.</param>
/// <returns>The MS2 spectrum with the ion information.</returns>
internal static XTSpectrum CalculateAllIons(XTSpectrum scanMS2)
{
// Calculate the spectrum ions
scanMS2 = CalcSpecIons(scanMS2);
// Get the domain range
scanMS2 = GetDomainRange(scanMS2);
// Get the correct modification index for the b-ions
scanMS2 = GetCorrectBIonModificationIndex(scanMS2);
// Get the correct modification index for the y-ions
scanMS2 = GetCorrectYIonModificationIndex(scanMS2);
// Find the possible b-ions
scanMS2 = FindPossibleBIons(scanMS2);
// Find the possible ytions
scanMS2 = FindPossibleYIons(scanMS2);
// Find the correct existing ions
scanMS2 = FindExistingIons(scanMS2);
return(scanMS2);
}
/// <summary>
/// Get the domain range.
/// </summary>
/// <param name="scanMS2">The spectrum.</param>
/// <returns>The spectrum with domain ranges.</returns>
internal static XTSpectrum GetDomainRange(XTSpectrum scanMS2)
{
// Get the domain start position
int dStart = scanMS2.Proteins[0].DomainStartPos;
// Get the domain end position
int dEnd = scanMS2.Proteins[0].DomainEndPos;
// Get the range length
int rangeLength = dEnd - dStart + 1;
// Get the domain range
int[] domainRange = Enumerable.Range(scanMS2.Proteins[0].DomainStartPos, rangeLength).ToArray();
// Get the reverse domain range
int[] domainRangeReverse = domainRange.Reverse().ToArray();
// Set the normal and reverse domain range to the spectrum
scanMS2.SpectrumDomainRange = domainRange;
scanMS2.SpectrumDomainRangeReverse = domainRangeReverse;
// Return the scan.
return(scanMS2);
}
/// <summary>
/// Get the quantified complementary arginine spectrum index.
/// </summary>
/// <param name="citMainSpectrum">The quantified main citrullination spectrum.</param>
/// <param name="complArgSpectra">The list of complementary arginine spectra.</param>
/// <returns>The index of the quantified complementary spectra in <paramref name="complArgSpectra"/>.</returns>
internal static int GetQuantifiedComplementaryArgSpectrumId(XTSpectrum citMainSpectrum, List <XTSpectrum> complArgSpectra)
{
// Get the ID of the complementary cit spectrum
if (citSpecSpecDict.TryGetValue(citMainSpectrum, out XTSpectrum complSpectrum))
{
// Get the compl spectrum ID
int spectrumId = complSpectrum.ID;
for (int i = 0; i < complArgSpectra.Count - 1; i++)
{
if (complArgSpectra[i].ID == spectrumId)
{
return(i);
}
}
}
// If no spectra is found, return 0
return(0);
}
/// <summary>
/// Get the quantified complementary citrullinated spectrum index.
/// </summary>
/// <param name="argMainSpectrum">The quantified main arginine spectrum.</param>
/// <param name="complCitSpectra">The list of complementary arginine scans.</param>
/// <returns>The index of the quantified complementary spectra in <paramref name="complCitSpectra"/>.</returns>
internal static int GetQuantifiedComplementaryCitSpectrumIndex(XTSpectrum argMainSpectrum, List <RawScan> complCitSpectra)
{
// Get the ID of the complementary cit spectrum
if (argSpecScanDict.TryGetValue(argMainSpectrum, out RawScan complSpectrum))
{
// Get the compl spectrum ID
int spectrumId = complSpectrum.ScanNumber;
for (int i = 0; i < complCitSpectra.Count - 1; i++)
{
if (complCitSpectra[i].ScanNumber == spectrumId)
{
return(i);
}
}
}
// If no spectra is found, return 0
return(0);
}
/// <summary>
/// Handle orphan spectra.
/// </summary>
/// <param name="spectrumMS2">The MS2 spectrum.</param>
/// <returns>The MS2 spectrum with a "false" parent.</returns>
internal static XTSpectrum HandleOrphanSpecs(XTSpectrum spectrumMS2)
{
// Create an array of MZ-values
double[] valMZ = { 100, 300, 500, 700, 900, 1100, 1300, spectrumMS2.PreCursorMz };
// Create an array of intensities
double[] valInt = { 30, 50, 100, 70, 40, 10, 20, 60 };
// Create a parent scan
var scanParent = new RawScan {
MzValues = valMZ, RetentionTime = 0, Intencities = valInt, TotalIonCount = 0
};
// If the spectrum is an orphan set the newly created scan to be the parent
if (spectrumMS2.Orphan == true)
{
spectrumMS2.ParentScan = scanParent;
}
// The spectrum with a parent
return(spectrumMS2);
}
/// <summary>
/// Check what state the quantificaation buttons should be in.
/// </summary>
/// <param name="spec">The spectrum.</param>
private void EnableQuantButtons(XTSpectrum spec)
{
// Check if the quantification list contains the spectrum.
if (Validation.argChosenForQuantList.Contains(spec.ID))
{
// If so, disable the add button
metroButtonAddQuant.Enabled = false;
// Enable the remove button
metroButtonRemoveQuant.Enabled = true;
// Prevent moving back and forth through the complementary spectra
metroButtonNextPotCitScan.Enabled = false;
metroButtonPrevPotCitScan.Enabled = false;
}
else
{
// If not, enable the add button
metroButtonAddQuant.Enabled = true;
// Disable the remove button
metroButtonRemoveQuant.Enabled = false;
}
}
/// <summary>
/// Get the correct modification index for the y-ions.
/// </summary>
/// <param name="scanMS2">The spectrum.</param>
/// <returns>The spectrum with the new information</returns>
internal static XTSpectrum GetCorrectYIonModificationIndex(XTSpectrum scanMS2)
{
// Create a new temporary list of modification indexes and their mass change
Dictionary <int, double> modDictY = new Dictionary <int, double>();
// Loop through all of the modifications
foreach (XTModification mod in scanMS2.Proteins[0].Modifications)
{
// Get the modification position and mass
int pos = mod.AtPosition;
double massChange = mod.MassChange;
// Get the index of the position in the reverse domain range
int index = Array.IndexOf(scanMS2.SpectrumDomainRangeReverse, pos);
// Check if the modification index already contains the index
if (modDictY.ContainsKey(index))
{
// If so.
// Get the old modification mass
modDictY.TryGetValue(index, out double oldMod);
// Add the old modification mass and the mass change
massChange = oldMod + massChange;
// Remove the old modification
modDictY.Remove(index);
// And add the new index with the new mass change
modDictY.Add(index, massChange);
}
else
{
// If no index already, add the mass charge.
modDictY.Add(index, massChange);
}
}
// Set the dictionary to the spectrum.
scanMS2.SpectrumYIonModDict = modDictY;
// Return the spectrum
return(scanMS2);
}
private static XTSpectrum ReturnSpec(XTSpectrum spec)
{
valSpec = spec;
return(valSpec);
}