public static void TestClassicSearchEngineTopDown()
{
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(protease: "top-down"),
scoreCutoff: 1,
assumeOrphanPeaksAreZ1Fragments: false);
MetaMorpheusTask.DetermineAnalyteType(CommonParameters);
// test output file name (should be proteoform and not peptide)
Assert.That(GlobalVariables.AnalyteType == "Proteoform");
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein>
{
new Protein("MPKVYSYQEVAEHNGPENFWIIIDDKVYDVSQFKDEHPGGDEIIMDLGGQDATESFVDIGHSDEALRLLKGLYIGDVDKTSERVSVEKVSTSENQSKGSGTLVVILAILMLGVAYYLLNE", "P40312")
};
var myMsDataFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TopDownTestData\slicedTDYeast.mzML"));
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>()).Run();
var psm = allPsmsArray.Where(p => p != null).FirstOrDefault();
Assert.That(psm.MatchedFragmentIons.Count == 47);
}
public static void OxoniumIonAnalysis()
{
Assert.That(Glycan.AllOxoniumIons[4] == 13805550);
Assert.That(Glycan.AllOxoniumIons[5] == 14406607);
Assert.That(Glycan.AllOxoniumIons[9] == 20408720);
Assert.That(Glycan.AllOxoniumIons[10] == 27409268);
Assert.That(Glycan.AllOxoniumIons[12] == 29210324);
Assert.That(Glycan.AllOxoniumIons[14] == 36614002);
//Get Scan
CommonParameters commonParameters = new CommonParameters(dissociationType: DissociationType.EThcD, trimMsMsPeaks: false);
string spectraFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"GlycoTestData\2019_09_16_StcEmix_35trig_EThcD25_rep1_4565.mgf");
var file = new MyFileManager(true).LoadFile(spectraFile, commonParameters);
var scan = MetaMorpheusTask.GetMs2Scans(file, spectraFile, commonParameters).First();
var productSearchMode = new SinglePpmAroundZeroSearchMode(20);
var oxoniumIonIntensities = GlycoPeptides.ScanOxoniumIonFilter(scan, productSearchMode, DissociationType.EThcD);
//Get glycanBox
var glycanBox = OGlycanBoxes[19];
var satifyOxonium = GlycoPeptides.OxoniumIonsAnalysis(oxoniumIonIntensities, glycanBox);
Assert.That(satifyOxonium);
}
public static void TestModernSearchEngineTopDown()
{
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(protease: "top-down"),
scoreCutoff: 1,
assumeOrphanPeaksAreZ1Fragments: false);
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein>
{
new Protein("MPKVYSYQEVAEHNGPENFWIIIDDKVYDVSQFKDEHPGGDEIIMDLGGQDATESFVDIGHSDEALRLLKGLYIGDVDKTSERVSVEKVSTSENQSKGSGTLVVILAILMLGVAYYLLNE", "P40312")
};
var myMsDataFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TopDownTestData\slicedTDYeast.mzML"));
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
var indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, null, 1, DecoyType.Reverse, CommonParameters, 30000, false, new List <FileInfo>(), new List <string>());
var indexResults = (IndexingResults)indexEngine.Run();
new ModernSearchEngine(allPsmsArray, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, 0, CommonParameters, searchMode, 0, new List <string>()).Run();
var psm = allPsmsArray.Where(p => p != null).FirstOrDefault();
Assert.That(psm.MatchedFragmentIons.Count > 50);
}
public static void TestResolveAmbiguities()
{
Protease protease = new Protease("Custom Protease4", CleavageSpecificity.Full, null, null, new List <DigestionMotif> {
new DigestionMotif("K", null, 1, "")
});
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
CommonParameters CommonParameters_t = new CommonParameters(
dissociationType: MassSpectrometry.DissociationType.HCD,
digestionParams: new DigestionParams(
protease: protease.Name,
minPeptideLength: 1),
scoreCutoff: 1,
reportAllAmbiguity: true);
var fsp_t = new List <(string fileName, CommonParameters fileSpecificParameters)>();
fsp_t.Add(("", CommonParameters_t));
CommonParameters CommonParameters_f = new CommonParameters(
dissociationType: MassSpectrometry.DissociationType.HCD,
digestionParams: new DigestionParams(
protease: protease.Name,
minPeptideLength: 1),
scoreCutoff: 1,
reportAllAmbiguity: false);
var fsp_f = new List <(string fileName, CommonParameters fileSpecificParameters)>();
fsp_f.Add(("", CommonParameters_t));
var myMsDataFile = new TestDataFile();
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein> {
new Protein("MNNKNKNKQQQ", "Prot1"), new Protein("MNNNKQQQ", "Prot2")
};
var searchModes = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray_withAmbiguity = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
PeptideSpectralMatch[] allPsmsArray_withOutAmbiguity = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
bool writeSpectralLibrary = false;
new ClassicSearchEngine(allPsmsArray_withAmbiguity, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchModes, CommonParameters_t, fsp_t, null, new List <string>(), writeSpectralLibrary).Run(); //report all ambiguity TRUE
new ClassicSearchEngine(allPsmsArray_withOutAmbiguity, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchModes, CommonParameters_f, fsp_f, null, new List <string>(), writeSpectralLibrary).Run(); //report all ambiguity FALSE
Assert.AreEqual("QQQ", allPsmsArray_withAmbiguity[0].BaseSequence);
Assert.AreEqual("QQQ", allPsmsArray_withOutAmbiguity[0].BaseSequence);
Assert.IsTrue(allPsmsArray_withAmbiguity[0].ProteinLength == null);
Assert.IsTrue(allPsmsArray_withOutAmbiguity[0].ProteinLength != null);
Assert.IsTrue(allPsmsArray_withAmbiguity[0].OneBasedStartResidueInProtein == null);
Assert.IsTrue(allPsmsArray_withOutAmbiguity[0].OneBasedStartResidueInProtein != null);
}
public static void TestCoIsolation()
{
List <DigestionMotif> motifs = new List <DigestionMotif> {
new DigestionMotif("K", null, 1, null)
};
Protease protease = new Protease("CustProtease", CleavageSpecificity.Full, null, null, motifs);
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
CommonParameters CommonParameters = new CommonParameters(scoreCutoff: 1, deconvolutionIntensityRatio: 50, digestionParams: new DigestionParams(protease.Name, minPeptideLength: 1));
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein> {
new Protein("MNNNKNDNK", null)
};
var searchModes = new SinglePpmAroundZeroSearchMode(5);
Proteomics.AminoAcidPolymer.Peptide pep1 = new Proteomics.AminoAcidPolymer.Peptide("NNNK");
Proteomics.AminoAcidPolymer.Peptide pep2 = new Proteomics.AminoAcidPolymer.Peptide("NDNK");
var dist1 = IsotopicDistribution.GetDistribution(pep1.GetChemicalFormula(), 0.1, 0.01);
var dist2 = IsotopicDistribution.GetDistribution(pep2.GetChemicalFormula(), 0.1, 0.01);
MsDataScan[] Scans = new MsDataScan[2];
double[] ms1intensities = new double[] { 0.8, 0.8, 0.2, 0.02, 0.2, 0.02 };
double[] ms1mzs = dist1.Masses.Concat(dist2.Masses).OrderBy(b => b).Select(b => b.ToMz(1)).ToArray();
double selectedIonMz = ms1mzs[1];
MzSpectrum MS1 = new MzSpectrum(ms1mzs, ms1intensities, false);
Scans[0] = new MsDataScan(MS1, 1, 1, false, Polarity.Positive, 1.0, new MzRange(300, 2000), "first spectrum", MZAnalyzerType.Unknown, MS1.SumOfAllY, null, null, "scan=1");
double[] ms2intensities = new double[] { 1, 1, 1, 1, 1 };
double[] ms2mzs = new double[] { 146.106.ToMz(1), 228.086.ToMz(1), 229.07.ToMz(1), 260.148.ToMz(1), 342.129.ToMz(1) };
MzSpectrum MS2 = new MzSpectrum(ms2mzs, ms2intensities, false);
double isolationMZ = selectedIonMz;
Scans[1] = new MsDataScan(MS2, 2, 2, false, Polarity.Positive, 2.0, new MzRange(100, 1500), "second spectrum", MZAnalyzerType.Unknown, MS2.SumOfAllY, null, null, "scan=2", selectedIonMz, null, null, isolationMZ, 2.5, DissociationType.HCD, 1, null);
var myMsDataFile = new MsDataFile(Scans, null);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters(deconvolutionIntensityRatio: 50)).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];;
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
// Two matches for this single scan! Corresponding to two co-isolated masses
Assert.AreEqual(2, allPsmsArray.Length);
Assert.IsTrue(allPsmsArray[0].Score > 1);
Assert.AreEqual(2, allPsmsArray[0].ScanNumber);
Assert.AreEqual("NNNK", allPsmsArray[0].BaseSequence);
Assert.AreEqual("NDNK", allPsmsArray[1].BaseSequence);
}
public static void ReplaceBadStdevTwo()
{
//here we are adding a really hydrophobic psm at the same time as a regular peptide so that there is a big difference in their computed hydrophobicities. The stdev of these hydrophobicities is out of whach the the collective and so it needs to get replaced by the global average
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var origDataFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML");
MyFileManager myFileManager = new MyFileManager(true);
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams());
var myMsDataFile = myFileManager.LoadFile(origDataFile, CommonParameters);
var searchModes = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = ProteinDbLoader.LoadProteinFasta(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\hela_snip_for_unitTest.fasta"), true, DecoyType.Reverse, false, ProteinDbLoader.UniprotAccessionRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotGeneNameRegex,
ProteinDbLoader.UniprotOrganismRegex, out var dbErrors, -1);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML", CommonParameters).OrderBy(b => b.PrecursorMass).ToArray();
//adding a new scan that creates a psm at an isolated retention time. This will ultimately cause PEP to replace its retention time standard deviation "Z-score" with the global average.
Ms2ScanWithSpecificMass topMs2Scan = listOfSortedms2Scans[395];
int newOneBasedScanNumber = 1000;
MzRange range = new MzRange(topMs2Scan.TheScan.MassSpectrum.XArray.Min(), topMs2Scan.TheScan.MassSpectrum.XArray.Max());
MzSpectrum mzs = new MzSpectrum(topMs2Scan.TheScan.MassSpectrum.XArray, topMs2Scan.TheScan.MassSpectrum.YArray, true);
double newRetentionTime = topMs2Scan.TheScan.RetentionTime - 25;
MsDataScan msd = new MsDataScan(mzs, newOneBasedScanNumber, 2, topMs2Scan.TheScan.IsCentroid, Polarity.Positive, newRetentionTime, range, "", MZAnalyzerType.Orbitrap, topMs2Scan.TheScan.TotalIonCurrent, topMs2Scan.TheScan.InjectionTime, topMs2Scan.TheScan.NoiseData, "", topMs2Scan.TheScan.SelectedIonMZ, topMs2Scan.TheScan.SelectedIonChargeStateGuess, topMs2Scan.TheScan.SelectedIonIntensity, topMs2Scan.TheScan.IsolationMz, topMs2Scan.TheScan.IsolationWidth, DissociationType.HCD, topMs2Scan.TheScan.OneBasedPrecursorScanNumber, topMs2Scan.TheScan.SelectedIonMonoisotopicGuessMz);
Ms2ScanWithSpecificMass mwsm = new Ms2ScanWithSpecificMass(msd, topMs2Scan.PrecursorMonoisotopicPeakMz, topMs2Scan.PrecursorCharge, topMs2Scan.FullFilePath, new CommonParameters(), topMs2Scan.ExperimentalFragments);
Ms2ScanWithSpecificMass[] extendedArray = new Ms2ScanWithSpecificMass[listOfSortedms2Scans.Length + 1];
for (int i = 0; i < listOfSortedms2Scans.Length; i++)
{
extendedArray[i] = listOfSortedms2Scans[i];
}
extendedArray[listOfSortedms2Scans.Length] = mwsm;
extendedArray = extendedArray.OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[extendedArray.Length];
new ClassicSearchEngine(allPsmsArray, extendedArray, variableModifications, fixedModifications, null, null, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
List <PeptideSpectralMatch> nonNullPsms = allPsmsArray.Where(p => p != null).ToList();
nonNullPsms = nonNullPsms.OrderByDescending(p => p.Score).ToList();
List <PeptideSpectralMatch> psmBloated = new List <PeptideSpectralMatch>();
psmBloated.AddRange(nonNullPsms);
int arrayMax = nonNullPsms.Count;
psmBloated.AddRange(nonNullPsms.GetRange(2, arrayMax - 2));
psmBloated.AddRange(nonNullPsms.GetRange(2, arrayMax - 2));
PeptideSpectralMatch pp = psmBloated.Where(p => p.ScanRetentionTime < (newRetentionTime + 1)).First();
PeptideWithSetModifications newPwsmTwo = new PeptideWithSetModifications(new Protein("WAGVLPWFPWAAVVWGFWF", "ACCESSION", "ORGANISM"), new DigestionParams(), 1, 2, CleavageSpecificity.Full, "", 0, new Dictionary <int, Modification>(), 0);
PeptideSpectralMatch newPsmTwo = new PeptideSpectralMatch(newPwsmTwo, pp.BestMatchingPeptides.First().Notch, pp.Score, pp.ScanIndex, mwsm, new DigestionParams(), pp.MatchedFragmentIons);
psmBloated.Add(newPsmTwo);
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(psmBloated.Where(p => p != null).ToList(), 1, CommonParameters, new List <string>()).Run());
}
public static void TestLookingForAcceptableIsotopicEnvelopes()
{
CommonParameters CommonParameters = new CommonParameters();
MetaMorpheusTask.DetermineAnalyteType(CommonParameters);
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein>
{
new Protein("AAAHSSLK", ""), new Protein("RQPAQPR", ""), new Protein("EKAEAEAEK", "")
};
var myMsDataFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\SmallCalibratible_Yeast.mzML"));
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
var ms2ScanTest = listOfSortedms2Scans[0];
//test when all the masses are not in the given range
//test1 when all the masses are too small
var test1 = ms2ScanTest.GetClosestExperimentalIsotopicEnvelopeList(50, 95);
Assert.AreEqual(test1, null);
//test2 when all the masses are too big
var test2 = ms2ScanTest.GetClosestExperimentalIsotopicEnvelopeList(582, 682);
Assert.AreEqual(test2, null);
//test3 when the mass which is bigger than given min mass is bigger than the mass which is smaller than the given max mass
//for example: the mass array is [1,2,3,4,5], the given min mass is 2.2, the given max mass is 2.8
var test3 = ms2ScanTest.GetClosestExperimentalIsotopicEnvelopeList(110, 111);
Assert.AreEqual(test3, null);
//test normal conditions:look for IsotopicEnvelopes which are in the range of acceptable mass
var test4 = ms2ScanTest.GetClosestExperimentalIsotopicEnvelopeList(120, 130);
IsotopicEnvelope[] expected4 = ms2ScanTest.ExperimentalFragments.Skip(15).Take(9).ToArray();
Assert.That(ms2ScanTest.ExperimentalFragments[15].MonoisotopicMass > 120 && ms2ScanTest.ExperimentalFragments[14].MonoisotopicMass < 120);
Assert.That(ms2ScanTest.ExperimentalFragments[23].MonoisotopicMass < 130 && ms2ScanTest.ExperimentalFragments[24].MonoisotopicMass > 130);
Assert.AreEqual(test4, expected4);
var test5 = ms2ScanTest.GetClosestExperimentalIsotopicEnvelopeList(400, 500);
IsotopicEnvelope[] expected5 = ms2ScanTest.ExperimentalFragments.Skip(150).Take(7).ToArray();
Assert.That(ms2ScanTest.ExperimentalFragments[150].MonoisotopicMass > 400 && ms2ScanTest.ExperimentalFragments[149].MonoisotopicMass < 400);
Assert.That(ms2ScanTest.ExperimentalFragments[156].MonoisotopicMass < 500 && ms2ScanTest.ExperimentalFragments[157].MonoisotopicMass > 500);
Assert.AreEqual(test5, expected5);
}
private static MassDiffAcceptor ParseSearchMode(string text)
{
MassDiffAcceptor massDiffAcceptor = null;
try
{
var split = text.Split(' ');
switch (split[1])
{
case "dot":
double[] massShifts = split[4].Split(',').Select(p => double.Parse(p, CultureInfo.InvariantCulture)).ToArray();
string newString = split[2].Replace("�", "");
double toleranceValue = double.Parse(newString, CultureInfo.InvariantCulture);
if (split[3].ToUpperInvariant().Equals("PPM"))
{
massDiffAcceptor = new DotMassDiffAcceptor(split[0], massShifts, new PpmTolerance(toleranceValue));
}
else if (split[3].ToUpperInvariant().Equals("DA"))
{
massDiffAcceptor = new DotMassDiffAcceptor(split[0], massShifts, new AbsoluteTolerance(toleranceValue));
}
break;
case "interval":
IEnumerable <DoubleRange> doubleRanges = Array.ConvertAll(split[2].Split(';'), b => new DoubleRange(double.Parse(b.Trim(new char[] { '[', ']' }).Split(',')[0],
CultureInfo.InvariantCulture), double.Parse(b.Trim(new char[] { '[', ']' }).Split(',')[1], CultureInfo.InvariantCulture)));
massDiffAcceptor = new IntervalMassDiffAcceptor(split[0], doubleRanges);
break;
case "OpenSearch":
massDiffAcceptor = new OpenSearchMode();
break;
case "daltonsAroundZero":
massDiffAcceptor = new SingleAbsoluteAroundZeroSearchMode(double.Parse(split[2], CultureInfo.InvariantCulture));
break;
case "ppmAroundZero":
massDiffAcceptor = new SinglePpmAroundZeroSearchMode(double.Parse(split[2], CultureInfo.InvariantCulture));
break;
default:
throw new MetaMorpheusException("Unrecognized search mode type: " + split[1]);
}
}
catch (Exception e)
{
throw new MetaMorpheusException("Could not parse search mode string: " + e.Message);
}
return(massDiffAcceptor);
}
public static void RemoveAmbiguousPeptides()
{
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var origDataFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML");
MyFileManager myFileManager = new MyFileManager(true);
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams());
var myMsDataFile = myFileManager.LoadFile(origDataFile, CommonParameters);
var searchModes = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = ProteinDbLoader.LoadProteinFasta(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\hela_snip_for_unitTest.fasta"), true, DecoyType.Reverse, false, ProteinDbLoader.UniprotAccessionRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotGeneNameRegex,
ProteinDbLoader.UniprotOrganismRegex, out var dbErrors, -1);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML", CommonParameters).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
var nonNullPsms = allPsmsArray.Where(p => p != null).ToList();
nonNullPsms.OrderByDescending(p => p.Score);
var maxScore = nonNullPsms.Select(n => n.Score).Max();
PeptideSpectralMatch maxScorePsm = nonNullPsms.Where(n => n.Score == maxScore).First();
Protein newProteinToRemove = new Protein("RREMVE", "BUBBA", isDecoy: false);
PeptideWithSetModifications pwsmToRemove = new PeptideWithSetModifications(newProteinToRemove, new DigestionParams(), 1, 6, CleavageSpecificity.Full, "peptideDescription", 2, new Dictionary <int, Modification>(), 1, "RREMVE");
maxScorePsm.AddOrReplace(pwsmToRemove, maxScore, 1, true, maxScorePsm.MatchedFragmentIons, maxScore);
maxScorePsm.ResolveAllAmbiguities();
List <PeptideSpectralMatch> psmBloated = new List <PeptideSpectralMatch>();
psmBloated.AddRange(nonNullPsms);
psmBloated.AddRange(nonNullPsms.GetRange(0, nonNullPsms.Count - 2));
foreach (PeptideSpectralMatch psm in nonNullPsms.GetRange(0, nonNullPsms.Count - 2))
{
Protein newDecoyProtein = new Protein(psm.BestMatchingPeptides.First().Peptide.BaseSequence + "K", "DECOY_" + psm.BestMatchingPeptides.First().Peptide.Protein.Accession, isDecoy: true);
PeptideWithSetModifications pwsmDecoy = new PeptideWithSetModifications(newDecoyProtein, new DigestionParams(), 1, psm.BestMatchingPeptides.First().Peptide.BaseSequence.Length + 1, CleavageSpecificity.Full, "peptideDescription", 2, new Dictionary <int, Modification>(), 1, psm.BestMatchingPeptides.First().Peptide.BaseSequence + "K");
PeptideSpectralMatch decoyPsm = new PeptideSpectralMatch(pwsmDecoy, 1, psm.Score, psm.ScanIndex, listOfSortedms2Scans[psm.ScanIndex], new DigestionParams(), psm.MatchedFragmentIons);
decoyPsm.ResolveAllAmbiguities();
psmBloated.Add(decoyPsm);
}
PeptideSpectralMatch oldBloatedMaxScorePsm = psmBloated.Where(n => n.Score == maxScore).First();
int countOfBestPeptidesBloatedMax = oldBloatedMaxScorePsm.BestMatchingPeptides.Count();
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(psmBloated.Where(p => p != null).ToList(), 1, CommonParameters, new List <string>()).Run());
PeptideSpectralMatch newMaxScorePsm = psmBloated.Where(n => n.Score == maxScore).First();
Assert.AreEqual(countOfBestPeptidesBloatedMax - 1, newMaxScorePsm.BestMatchingPeptides.Count());
}
private static MassDiffAcceptor ParseSearchMode(string text)
{
MassDiffAcceptor ye = null;
var split = text.Split(' ');
switch (split[1])
{
case "dot":
var massShifts = Array.ConvertAll(split[4].Split(','), Double.Parse);
var newString = split[2].Replace("�", "");
var toleranceValue = double.Parse(newString, CultureInfo.InvariantCulture);
if (split[3].ToUpperInvariant().Equals("PPM"))
{
ye = new DotMassDiffAcceptor(split[0], massShifts, new PpmTolerance(toleranceValue));
}
else if (split[3].ToUpperInvariant().Equals("DA"))
{
ye = new DotMassDiffAcceptor(split[0], massShifts, new AbsoluteTolerance(toleranceValue));
}
break;
case "interval":
IEnumerable <DoubleRange> doubleRanges = Array.ConvertAll(split[2].Split(','), b => new DoubleRange(double.Parse(b.Trim(new char[] { '[', ']' }).Split(';')[0], CultureInfo.InvariantCulture), double.Parse(b.Trim(new char[] { '[', ']' }).Split(';')[1], CultureInfo.InvariantCulture)));
ye = new IntervalMassDiffAcceptor(split[0], doubleRanges);
break;
case "OpenSearch":
ye = new OpenSearchMode();
break;
case "daltonsAroundZero":
ye = new SingleAbsoluteAroundZeroSearchMode(double.Parse(split[2], CultureInfo.InvariantCulture));
break;
case "ppmAroundZero":
ye = new SinglePpmAroundZeroSearchMode(double.Parse(split[2], CultureInfo.InvariantCulture));
break;
default:
throw new MetaMorpheusException("Could not parse search mode string");
}
return(ye);
}
public static void AnotherSpectralLibrarySearchTestDecoy()
{
var testDir = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\SpectralLibrarySearch");
string myFile = Path.Combine(testDir, @"slicedMouse.raw");
MyFileManager myFileManager = new MyFileManager(true);
CommonParameters commonParameters = new CommonParameters(maxThreadsToUsePerFile: 1, scoreCutoff: 1);
MsDataFile myMsDataFile = myFileManager.LoadFile(myFile, commonParameters);
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein> {
new Protein("QTATIAHVTTMLGEVIGFNDHIVK", "P16858")
};
string targetSpectralLibrary = Path.Combine(testDir, @"P16858_target.msp");
string decoySpectralLibrary = Path.Combine(testDir, @"P16858_decoy.msp");
List <string> specLibs = new List <string> {
targetSpectralLibrary, decoySpectralLibrary
};
SpectralLibrary sl = new SpectralLibrary(specLibs);
var searchModes = new SinglePpmAroundZeroSearchMode(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
bool writeSpectralLibrary = false;
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchModes, commonParameters, null, sl, new List <string>(), writeSpectralLibrary).Run();
// Single search mode
Assert.AreEqual(7, allPsmsArray.Length);
Assert.IsTrue(allPsmsArray[5].Score > 38);
Assert.AreEqual("VIHDNFGIVEGLMTTVHAITATQK", allPsmsArray[5].BaseSequence);
Assert.IsTrue(allPsmsArray[5].IsDecoy);
SpectralLibrarySearchFunction.CalculateSpectralAngles(sl, allPsmsArray, listOfSortedms2Scans, commonParameters);
Assert.That(allPsmsArray[5].SpectralAngle, Is.EqualTo(0.69).Within(0.01));
}
public static void TestDeltaValues()
{
CommonParameters CommonParameters = new CommonParameters(scoreCutoff: 1, useDeltaScore: true, digestionParams: new DigestionParams(minPeptideLength: 5));
SearchParameters SearchParameters = new SearchParameters
{
MassDiffAcceptorType = MassDiffAcceptorType.Exact,
};
List <Modification> variableModifications = GlobalVariables.AllModsKnown.OfType <Modification>().Where(b => CommonParameters.ListOfModsVariable.Contains((b.ModificationType, b.IdWithMotif))).ToList();
List <Modification> fixedModifications = GlobalVariables.AllModsKnown.OfType <Modification>().Where(b => CommonParameters.ListOfModsFixed.Contains((b.ModificationType, b.IdWithMotif))).ToList();
// Generate data for files
Protein TargetProtein1 = new Protein("TIDEANTHE", "accession1");
Protein TargetProtein2 = new Protein("TIDELVE", "accession2");
Protein TargetProtein3 = new Protein("TIDENIE", "accession3");
Protein TargetProteinLost = new Protein("PEPTIDEANTHE", "accession4");
Protein DecoyProteinFound = new Protein("PETPLEDQGTHE", "accessiond", isDecoy: true);
MsDataFile myMsDataFile = new TestDataFile(new List <PeptideWithSetModifications>
{
TargetProtein1.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein2.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein3.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
DecoyProteinFound.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0]
});
var proteinList = new List <Protein> {
TargetProtein1, TargetProtein2, TargetProtein3, TargetProteinLost, DecoyProteinFound
};
var searchModes = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
//check better when using delta
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
var indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, null, 1, DecoyType.None, CommonParameters, 30000, false, new List <FileInfo>(), new List <string>());
var indexResults = (IndexingResults)indexEngine.Run();
MassDiffAcceptor massDiffAcceptor = SearchTask.GetMassDiffAcceptor(CommonParameters.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
PeptideSpectralMatch[] allPsmsArrayModern = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArrayModern, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, 0, CommonParameters, massDiffAcceptor, 0, new List <string>()).Run();
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
FdrAnalysisResults fdrResultsModernDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArrayModern.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassicDelta.PsmsWithin1PercentFdr == 3);
Assert.IsTrue(fdrResultsModernDelta.PsmsWithin1PercentFdr == 3);
CommonParameters = new CommonParameters(digestionParams: new DigestionParams(minPeptideLength: 5));
//check worse when using score
FdrAnalysisResults fdrResultsClassic = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
FdrAnalysisResults fdrResultsModern = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassic.PsmsWithin1PercentFdr == 0);
Assert.IsTrue(fdrResultsModern.PsmsWithin1PercentFdr == 0);
//check that when delta is bad, we used the score
// Generate data for files
Protein DecoyProtein1 = new Protein("TLEDAGGTHE", "accession1d", isDecoy: true);
Protein DecoyProtein2 = new Protein("TLEDLVE", "accession2d", isDecoy: true);
Protein DecoyProtein3 = new Protein("TLEDNIE", "accession3d", isDecoy: true);
Protein DecoyProteinShiny = new Protein("GGGGGG", "accessionShinyd", isDecoy: true);
myMsDataFile = new TestDataFile(new List <PeptideWithSetModifications>
{
TargetProtein1.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein2.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein3.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
DecoyProteinShiny.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
});
proteinList = new List <Protein>
{
TargetProtein1, DecoyProtein1,
TargetProtein2, DecoyProtein2,
TargetProtein3, DecoyProtein3,
DecoyProteinShiny,
};
listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
//check no change when using delta
allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
CommonParameters = new CommonParameters(useDeltaScore: true, digestionParams: new DigestionParams(minPeptideLength: 5));
indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, null, 1, DecoyType.None, CommonParameters, 30000, false, new List <FileInfo>(), new List <string>());
indexResults = (IndexingResults)indexEngine.Run();
massDiffAcceptor = SearchTask.GetMassDiffAcceptor(CommonParameters.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
allPsmsArrayModern = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArrayModern, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, 0, CommonParameters, massDiffAcceptor, 0, new List <string>()).Run();
fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
fdrResultsModernDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArrayModern.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassicDelta.PsmsWithin1PercentFdr == 3);
Assert.IsTrue(fdrResultsModernDelta.PsmsWithin1PercentFdr == 3);
CommonParameters = new CommonParameters(digestionParams: new DigestionParams(minPeptideLength: 5));
//check no change when using score
fdrResultsClassic = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
fdrResultsModern = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArrayModern.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassic.PsmsWithin1PercentFdr == 3);
Assert.IsTrue(fdrResultsModern.PsmsWithin1PercentFdr == 3);
}
public static void TestDeltaValues()
{
CommonParameters CommonParameters = new CommonParameters(scoreCutoff: 1, useDeltaScore: true, digestionParams: new DigestionParams(minPeptideLength: 5));
SearchParameters SearchParameters = new SearchParameters
{
MassDiffAcceptorType = MassDiffAcceptorType.Exact,
};
List <ModificationWithMass> variableModifications = GlobalVariables.AllModsKnown.OfType <ModificationWithMass>().Where(b => CommonParameters.ListOfModsVariable.Contains((b.modificationType, b.id))).ToList();
List <ModificationWithMass> fixedModifications = GlobalVariables.AllModsKnown.OfType <ModificationWithMass>().Where(b => CommonParameters.ListOfModsFixed.Contains((b.modificationType, b.id))).ToList();
// Generate data for files
Protein TargetProtein1 = new Protein("TIDEANTHE", "accession1");
Protein TargetProtein2 = new Protein("TIDELVE", "accession2");
Protein TargetProtein3 = new Protein("TIDENIE", "accession3");
Protein TargetProteinLost = new Protein("PEPTIDEANTHE", "accession4");
Protein DecoyProteinFound = new Protein("PETPLEDQGTHE", "accessiond", isDecoy: true);
MsDataFile myMsDataFile = new TestDataFile(new List <PeptideWithSetModifications>
{
TargetProtein1.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein2.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein3.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
DecoyProteinFound.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0]
});
var proteinList = new List <Protein> {
TargetProtein1, TargetProtein2, TargetProtein3, TargetProteinLost, DecoyProteinFound
};
var searchModes = new SinglePpmAroundZeroSearchMode(5);
bool DoPrecursorDeconvolution = true;
bool UseProvidedPrecursorInfo = true;
double DeconvolutionIntensityRatio = 4;
int DeconvolutionMaxAssumedChargeState = 10;
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, DoPrecursorDeconvolution, UseProvidedPrecursorInfo, DeconvolutionIntensityRatio, DeconvolutionMaxAssumedChargeState, DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
//check better when using delta
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, proteinList, new List <ProductType> {
ProductType.B, ProductType.Y
}, searchModes, CommonParameters, new List <string>()).Run();
var indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, new List <ProductType>
{
ProductType.B, ProductType.Y
}, 1, DecoyType.None, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters, 30000, new List <string>());
var indexResults = (IndexingResults)indexEngine.Run();
MassDiffAcceptor massDiffAcceptor = SearchTask.GetMassDiffAcceptor(CommonParameters.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
PeptideSpectralMatch[] allPsmsArrayModern = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArrayModern, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, new List <ProductType> {
ProductType.B, ProductType.Y
}, 0, CommonParameters, massDiffAcceptor, 0, new List <string>()).Run();
Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> > compactPeptideToProteinPeptideMatching =
new Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> >();
if (proteinList.Any())
{
SequencesToActualProteinPeptidesEngine sequencesToActualProteinPeptidesEngine = new SequencesToActualProteinPeptidesEngine(allPsmsArray.ToList(), proteinList, fixedModifications, variableModifications, new List <ProductType>
{
ProductType.B, ProductType.Y
}, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, CommonParameters, new List <string>());
var res = (SequencesToActualProteinPeptidesEngineResults)sequencesToActualProteinPeptidesEngine.Run();
compactPeptideToProteinPeptideMatching = res.CompactPeptideToProteinPeptideMatching;
}
foreach (var psm in allPsmsArray)
{
psm.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching);
}
foreach (var psm in allPsmsArrayModern)
{
psm.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching);
}
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
FdrAnalysisResults fdrResultsModernDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArrayModern.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassicDelta.PsmsWithin1PercentFdr == 3);
Assert.IsTrue(fdrResultsModernDelta.PsmsWithin1PercentFdr == 3);
CommonParameters = new CommonParameters(digestionParams: new DigestionParams(minPeptideLength: 5));
//check worse when using score
FdrAnalysisResults fdrResultsClassic = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
FdrAnalysisResults fdrResultsModern = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassic.PsmsWithin1PercentFdr == 0);
Assert.IsTrue(fdrResultsModern.PsmsWithin1PercentFdr == 0);
//check that when delta is bad, we used the score
// Generate data for files
Protein DecoyProtein1 = new Protein("TLEDAGGTHE", "accession1d", isDecoy: true);
Protein DecoyProtein2 = new Protein("TLEDLVE", "accession2d", isDecoy: true);
Protein DecoyProtein3 = new Protein("TLEDNIE", "accession3d", isDecoy: true);
Protein DecoyProteinShiny = new Protein("GGGGGG", "accessionShinyd", isDecoy: true);
myMsDataFile = new TestDataFile(new List <PeptideWithSetModifications>
{
TargetProtein1.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein2.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
TargetProtein3.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
DecoyProteinShiny.Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[0],
});
proteinList = new List <Protein>
{
TargetProtein1, DecoyProtein1,
TargetProtein2, DecoyProtein2,
TargetProtein3, DecoyProtein3,
DecoyProteinShiny,
};
listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, DoPrecursorDeconvolution, UseProvidedPrecursorInfo, DeconvolutionIntensityRatio, DeconvolutionMaxAssumedChargeState, DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
//check no change when using delta
allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, proteinList, new List <ProductType> {
ProductType.B, ProductType.Y
}, searchModes, CommonParameters, new List <string>()).Run();
CommonParameters = new CommonParameters(useDeltaScore: true, digestionParams: new DigestionParams(minPeptideLength: 5));
indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, new List <ProductType>
{
ProductType.B, ProductType.Y
}, 1, DecoyType.None, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters, 30000, new List <string>());
indexResults = (IndexingResults)indexEngine.Run();
massDiffAcceptor = SearchTask.GetMassDiffAcceptor(CommonParameters.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
allPsmsArrayModern = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArrayModern, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, new List <ProductType> {
ProductType.B, ProductType.Y
}, 0, CommonParameters, massDiffAcceptor, 0, new List <string>()).Run();
var compactPeptideToProteinPeptideMatching2 = new Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> >();
if (proteinList.Any())
{
SequencesToActualProteinPeptidesEngine sequencesToActualProteinPeptidesEngine2 = new SequencesToActualProteinPeptidesEngine(allPsmsArray.ToList(), proteinList, fixedModifications, variableModifications, new List <ProductType> {
ProductType.B, ProductType.Y
}, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, CommonParameters, new List <string>());
var res = (SequencesToActualProteinPeptidesEngineResults)sequencesToActualProteinPeptidesEngine2.Run();
compactPeptideToProteinPeptideMatching2 = res.CompactPeptideToProteinPeptideMatching;
}
foreach (var psm in allPsmsArray)
{
psm.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching2);
}
foreach (var psm in allPsmsArrayModern)
{
psm.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching2);
}
fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
fdrResultsModernDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArrayModern.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassicDelta.PsmsWithin1PercentFdr == 3);
Assert.IsTrue(fdrResultsModernDelta.PsmsWithin1PercentFdr == 3);
CommonParameters = new CommonParameters(digestionParams: new DigestionParams(minPeptideLength: 5));
//check no change when using score
fdrResultsClassic = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.ToList(), 1, CommonParameters, new List <string>()).Run());
fdrResultsModern = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArrayModern.ToList(), 1, CommonParameters, new List <string>()).Run());
Assert.IsTrue(fdrResultsClassic.PsmsWithin1PercentFdr == 3);
Assert.IsTrue(fdrResultsModern.PsmsWithin1PercentFdr == 3);
}
public static void TestComputePEPValue()
{
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var origDataFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML");
MyFileManager myFileManager = new MyFileManager(true);
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams());
var myMsDataFile = myFileManager.LoadFile(origDataFile, CommonParameters);
var searchModes = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = ProteinDbLoader.LoadProteinFasta(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\hela_snip_for_unitTest.fasta"), true, DecoyType.Reverse, false, ProteinDbLoader.UniprotAccessionRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotGeneNameRegex,
ProteinDbLoader.UniprotOrganismRegex, out var dbErrors, -1);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, CommonParameters).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.Where(p => p != null).ToList(), 1, CommonParameters, new List <string>()).Run());
var nonNullPsms = allPsmsArray.Where(p => p != null).ToList();
var nonNullPsmsOriginalCopy = allPsmsArray.Where(p => p != null).ToList();
var accessionCounts = PEP_Analysis.GetAccessionCounts(nonNullPsms);
var maxScore = nonNullPsms.Select(n => n.Score).Max();
var maxScorePsm = nonNullPsms.Where(n => n.Score == maxScore).First();
Dictionary <string, int> sequenceToPsmCount = new Dictionary <string, int>();
List <string> sequences = new List <string>();
foreach (PeptideSpectralMatch psm in nonNullPsms)
{
var ss = psm.BestMatchingPeptides.Select(b => b.Peptide.FullSequence).ToList();
sequences.Add(String.Join("|", ss));
}
var s = sequences.GroupBy(i => i);
foreach (var grp in s)
{
sequenceToPsmCount.Add(grp.Key, grp.Count());
}
var maxPsmData = PEP_Analysis.CreateOnePsmDataFromPsm(maxScorePsm, accessionCounts, sequenceToPsmCount);
Assert.That(maxScorePsm.PeptidesToMatchingFragments.Count, Is.EqualTo(maxPsmData.Ambiguity));
Assert.That(maxScorePsm.DeltaScore, Is.EqualTo(maxPsmData.DeltaScore).Within(0.05));
Assert.That((float)(maxScorePsm.Score - (int)maxScorePsm.Score), Is.EqualTo(maxPsmData.Intensity).Within(0.05));
Assert.That(maxScorePsm.BestMatchingPeptides.Select(p => p.Peptide).First().MissedCleavages, Is.EqualTo(maxPsmData.MissedCleavagesCount));
Assert.That(maxScorePsm.BestMatchingPeptides.Select(p => p.Peptide).First().AllModsOneIsNterminus.Values.Count(), Is.EqualTo(maxPsmData.ModsCount));
Assert.That(maxScorePsm.Notch ?? 0, Is.EqualTo(maxPsmData.Notch));
Assert.That(maxScorePsm.PsmCount, Is.EqualTo(maxPsmData.PsmCount));
Assert.That(maxScorePsm.ScanPrecursorCharge, Is.EqualTo(maxPsmData.ScanPrecursorCharge));
PEP_Analysis.ComputePEPValuesForAllPSMsGeneric(nonNullPsms);
int trueCount = 0;
foreach (var item in allPsmsArray.Where(p => p != null))
{
var b = item.FdrInfo.PEP;
if (b >= 0.5)
{
trueCount++;
}
}
Assert.GreaterOrEqual(32, trueCount);
}
public static void TestMatchIonsOfAllChargesBottomUp()
{
CommonParameters CommonParameters = new CommonParameters();
MetaMorpheusTask.DetermineAnalyteType(CommonParameters);
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein>
{
new Protein("AAAHSSLK", ""), new Protein("RQPAQPR", ""), new Protein("EKAEAEAEK", "")
};
var myMsDataFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\SmallCalibratible_Yeast.mzML"));
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
//search by new method of looking for all charges
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>(), true).Run();
var psm = allPsmsArray.Where(p => p != null).ToList();
Assert.That(psm[1].MatchedFragmentIons.Count == 14);
//there are ions with same product type and same fragment number but different charges
Assert.That(psm[1].MatchedFragmentIons[8].NeutralTheoreticalProduct.ProductType == psm[1].MatchedFragmentIons[9].NeutralTheoreticalProduct.ProductType &&
psm[1].MatchedFragmentIons[8].NeutralTheoreticalProduct.FragmentNumber == psm[1].MatchedFragmentIons[9].NeutralTheoreticalProduct.FragmentNumber &&
psm[1].MatchedFragmentIons[8].Charge != psm[1].MatchedFragmentIons[9].Charge);
Assert.That(psm[2].MatchedFragmentIons.Count == 14);
Assert.That(psm[4].MatchedFragmentIons.Count == 16);
//search by old method of looking for only one charge
PeptideSpectralMatch[] allPsmsArray_oneCharge = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray_oneCharge, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>(), false).Run();
var psm_oneCharge = allPsmsArray_oneCharge.Where(p => p != null).ToList();
//compare 2 scores , they should have same integer part but new search has a little higher score than old search
Assert.That(psm[1].Score > psm_oneCharge[1].Score);
Assert.AreEqual(Math.Truncate(psm[1].Score), 12);
Assert.AreEqual(Math.Truncate(psm_oneCharge[1].Score), 12);
//compare 2 results and evaluate the different matched ions
var peptideTheorProducts = new List <Product>();
Assert.That(psm_oneCharge[1].MatchedFragmentIons.Count == 12);
var differences = psm[1].MatchedFragmentIons.Except(psm_oneCharge[1].MatchedFragmentIons);
psm[1].BestMatchingPeptides.First().Peptide.Fragment(CommonParameters.DissociationType, CommonParameters.DigestionParams.FragmentationTerminus, peptideTheorProducts);
foreach (var ion in differences)
{
foreach (var product in peptideTheorProducts)
{
if (product.Annotation.ToString().Equals(ion.NeutralTheoreticalProduct.Annotation.ToString()))
{
//to see if the different matched ions are qualified
Assert.That(CommonParameters.ProductMassTolerance.Within(ion.Mz.ToMass(ion.Charge), product.NeutralMass));
}
}
}
//test specific condition: unknown fragment mass; this only happens rarely for sequences with unknown amino acids
var myMsDataFile1 = new TestDataFile();
var variableModifications1 = new List <Modification>();
var fixedModifications1 = new List <Modification>();
var proteinList1 = new List <Protein> {
new Protein("QXQ", null)
};
var productMassTolerance = new AbsoluteTolerance(0.01);
var searchModes = new OpenSearchMode();
Tolerance DeconvolutionMassTolerance1 = new PpmTolerance(5);
var listOfSortedms2Scans1 = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
List <DigestionMotif> motifs = new List <DigestionMotif> {
new DigestionMotif("K", null, 1, null)
};
Protease protease = new Protease("Custom Protease3", CleavageSpecificity.Full, null, null, motifs);
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
CommonParameters CommonParameters1 = new CommonParameters(
digestionParams: new DigestionParams(protease: protease.Name, maxMissedCleavages: 0, minPeptideLength: 1),
scoreCutoff: 1,
addCompIons: false);
var fsp = new List <(string fileName, CommonParameters fileSpecificParameters)>();
fsp.Add(("", CommonParameters));
PeptideSpectralMatch[] allPsmsArray1 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
bool writeSpectralLibrary = true;
new ClassicSearchEngine(allPsmsArray1, listOfSortedms2Scans1, variableModifications1, fixedModifications1, null, null, null,
proteinList1, searchModes, CommonParameters1, fsp, null, new List <string>(), writeSpectralLibrary).Run();
var psm1 = allPsmsArray1.Where(p => p != null).ToList();
Assert.AreEqual(psm1.Count, 222);
}
public static void TestReverseDecoyGenerationDuringSearch()
{
CommonParameters CommonParameters = new CommonParameters();
MetaMorpheusTask.DetermineAnalyteType(CommonParameters);
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein>
{
new Protein("KKAEDGINK", ""), new Protein("AVNSISLK", ""), new Protein("EKAEAEAEK", ""), new Protein("DITANLR", ""), new Protein("QNAIGTAK", ""),
new Protein("FHKSQLNK", ""), new Protein("KQVAQWNK", ""), new Protein("NTRIEELK", ""), new Protein("RQPAQPR", ""),
};
var myMsDataFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\SmallCalibratible_Yeast.mzML"));
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
var path = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\myPrositLib.msp");
var testLibrary = new SpectralLibrary(new List <string> {
path
});
//test when doing spectral library search without generating library
PeptideSpectralMatch[] allPsmsArray1 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray1, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, testLibrary, new List <string>(), false).Run();
var psm1 = allPsmsArray1.Where(p => p != null).ToList();
Assert.That(psm1[0].IsDecoy == false && psm1[0].FullSequence == "DITANLR");
Assert.That(psm1[1].IsDecoy == true && psm1[1].FullSequence == "LSISNVAK");
Assert.That(psm1[2].IsDecoy == true && psm1[2].FullSequence == "LSISNVAK");
Assert.That(psm1[3].IsDecoy == false && psm1[3].FullSequence == "RQPAQPR");
Assert.That(psm1[4].IsDecoy == false && psm1[4].FullSequence == "KKAEDGINK");
Assert.That(psm1[5].IsDecoy == false && psm1[5].FullSequence == "EKAEAEAEK");
Assert.That(psm1[6].IsDecoy == false && psm1[6].FullSequence == "EKAEAEAEK");
proteinList.Add(new Protein("LSISNVAK", "", isDecoy: true));
//test when doing spectral library search with generating library; non spectral search won't generate decoy by "decoy on the fly" , so proteinlist used by non spectral library search would contain decoys
PeptideSpectralMatch[] allPsmsArray2 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray2, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, testLibrary, new List <string>(), true).Run();
var psm2 = allPsmsArray2.Where(p => p != null).ToList();
Assert.That(psm2[0].IsDecoy == false && psm2[0].FullSequence == "DITANLR");
Assert.That(psm2[1].IsDecoy == true && psm2[1].FullSequence == "LSISNVAK");
Assert.That(psm2[2].IsDecoy == true && psm2[2].FullSequence == "LSISNVAK");
Assert.That(psm2[3].IsDecoy == false && psm2[3].FullSequence == "RQPAQPR");
Assert.That(psm2[4].IsDecoy == false && psm2[4].FullSequence == "KKAEDGINK");
Assert.That(psm2[5].IsDecoy == false && psm2[5].FullSequence == "EKAEAEAEK");
Assert.That(psm2[6].IsDecoy == false && psm2[6].FullSequence == "EKAEAEAEK");
//test when doing non spectral library search without generating library
PeptideSpectralMatch[] allPsmsArray3 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray3, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>(), false).Run();
var psm3 = allPsmsArray3.Where(p => p != null).ToList();
Assert.That(psm3[0].IsDecoy == false && psm3[0].FullSequence == "DITANLR");
Assert.That(psm3[1].IsDecoy == true && psm3[1].FullSequence == "LSISNVAK");
Assert.That(psm3[2].IsDecoy == true && psm3[2].FullSequence == "LSISNVAK");
Assert.That(psm3[3].IsDecoy == false && psm3[3].FullSequence == "RQPAQPR");
Assert.That(psm3[4].IsDecoy == false && psm3[4].FullSequence == "KKAEDGINK");
Assert.That(psm3[5].IsDecoy == false && psm3[5].FullSequence == "EKAEAEAEK");
Assert.That(psm3[6].IsDecoy == false && psm3[6].FullSequence == "EKAEAEAEK");
//test when doing non spectral library search with generating library
PeptideSpectralMatch[] allPsmsArray4 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray4, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>(), true).Run();
var psm4 = allPsmsArray4.Where(p => p != null).ToList();
Assert.That(psm4[0].IsDecoy == false && psm4[0].FullSequence == "DITANLR");
Assert.That(psm4[1].IsDecoy == true && psm4[1].FullSequence == "LSISNVAK");
Assert.That(psm4[2].IsDecoy == true && psm4[2].FullSequence == "LSISNVAK");
Assert.That(psm4[3].IsDecoy == false && psm4[3].FullSequence == "RQPAQPR");
Assert.That(psm4[4].IsDecoy == false && psm4[4].FullSequence == "KKAEDGINK");
Assert.That(psm4[5].IsDecoy == false && psm4[5].FullSequence == "EKAEAEAEK");
Assert.That(psm4[6].IsDecoy == false && psm4[6].FullSequence == "EKAEAEAEK");
//compare psm's target/decoy results in 4 conditions. they should be same as new decoy methods shouldn't change the t/d results
for (int i = 0; i < psm1.Count; i++)
{
Assert.That(psm1[i].FullSequence == psm2[i].FullSequence && psm3[i].FullSequence == psm3[i].FullSequence && psm2[i].FullSequence == psm3[i].FullSequence);
Assert.That(psm1[i].IsDecoy == psm2[i].IsDecoy && psm3[i].IsDecoy == psm3[i].IsDecoy && psm2[i].IsDecoy == psm3[i].IsDecoy);
}
//compare MetaMorpheus scores in 4 conditions; for some psms, they should have a little higher score when "generating library" as they switch to all charges ions matching function
for (int j = 0; j < psm1.Count; j++)
{
if (psm1[j].FullSequence == psm2[j].FullSequence && psm1[j].MatchedFragmentIons.Count != psm2[j].MatchedFragmentIons.Count)
{
Assert.That(psm1[j].Score < psm2[j].Score);
}
}
}
public static void TestCoIsolation()
{
Protease protease = new Protease("CustProtease", new List <Tuple <string, TerminusType> > {
new Tuple <string, TerminusType>("K", TerminusType.C)
}, new List <Tuple <string, TerminusType> >(), CleavageSpecificity.Full, null, null, null);
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
CommonParameters CommonParameters = new CommonParameters(scoreCutoff: 1, deconvolutionIntensityRatio: 50, digestionParams: new DigestionParams(protease.Name, minPeptideLength: 1));
var variableModifications = new List <ModificationWithMass>();
var fixedModifications = new List <ModificationWithMass>();
var proteinList = new List <Protein> {
new Protein("MNNNKNDNK", null)
};
var searchModes = new SinglePpmAroundZeroSearchMode(5);
Proteomics.AminoAcidPolymer.Peptide pep1 = new Proteomics.AminoAcidPolymer.Peptide("NNNK");
Proteomics.AminoAcidPolymer.Peptide pep2 = new Proteomics.AminoAcidPolymer.Peptide("NDNK");
var dist1 = IsotopicDistribution.GetDistribution(pep1.GetChemicalFormula(), 0.1, 0.01);
var dist2 = IsotopicDistribution.GetDistribution(pep2.GetChemicalFormula(), 0.1, 0.01);
MsDataScan[] Scans = new MsDataScan[2];
double[] ms1intensities = new double[] { 0.8, 0.8, 0.2, 0.02, 0.2, 0.02 };
double[] ms1mzs = dist1.Masses.Concat(dist2.Masses).OrderBy(b => b).Select(b => b.ToMz(1)).ToArray();
double selectedIonMz = ms1mzs[1];
MzSpectrum MS1 = new MzSpectrum(ms1mzs, ms1intensities, false);
Scans[0] = new MsDataScan(MS1, 1, 1, false, Polarity.Positive, 1.0, new MzRange(300, 2000), "first spectrum", MZAnalyzerType.Unknown, MS1.SumOfAllY, null, null, "scan=1");
double[] ms2intensities = new double[] { 1, 1, 1, 1, 1 };
double[] ms2mzs = new double[] { 146.106.ToMz(1), 228.086.ToMz(1), 229.07.ToMz(1), 260.148.ToMz(1), 342.129.ToMz(1) };
MzSpectrum MS2 = new MzSpectrum(ms2mzs, ms2intensities, false);
double isolationMZ = selectedIonMz;
Scans[1] = new MsDataScan(MS2, 2, 2, false, Polarity.Positive, 2.0, new MzRange(100, 1500), "second spectrum", MZAnalyzerType.Unknown, MS2.SumOfAllY, null, null, "scan=2", selectedIonMz, null, null, isolationMZ, 2.5, DissociationType.HCD, 1, null);
var myMsDataFile = new MsDataFile(Scans, null);
bool DoPrecursorDeconvolution = true;
bool UseProvidedPrecursorInfo = true;
double DeconvolutionIntensityRatio = 50;
int DeconvolutionMaxAssumedChargeState = 10;
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, DoPrecursorDeconvolution, UseProvidedPrecursorInfo, DeconvolutionIntensityRatio, DeconvolutionMaxAssumedChargeState, DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
List <ProductType> lp = new List <ProductType> {
ProductType.B, ProductType.Y
};
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, proteinList, lp, searchModes, CommonParameters, new List <string>()).Run();
// Two matches for this single scan! Corresponding to two co-isolated masses
Assert.AreEqual(2, allPsmsArray.Length);
Assert.IsTrue(allPsmsArray[0].Score > 1);
Assert.AreEqual(2, allPsmsArray[0].ScanNumber);
var ojdfkj = (SequencesToActualProteinPeptidesEngineResults) new SequencesToActualProteinPeptidesEngine(new List <PeptideSpectralMatch>
{
allPsmsArray[0], allPsmsArray[1]
}, proteinList, fixedModifications, variableModifications, lp, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, CommonParameters, new List <string>()).Run();
foreach (var huh in allPsmsArray)
{
if (huh != null)
{
huh.MatchToProteinLinkedPeptides(ojdfkj.CompactPeptideToProteinPeptideMatching);
}
}
Assert.AreEqual("NNNK", allPsmsArray[0].BaseSequence);
Assert.AreEqual("NDNK", allPsmsArray[1].BaseSequence);
}
public static void TestComputePEPValue()
{
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var origDataFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML");
MyFileManager myFileManager = new MyFileManager(true);
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams());
var myMsDataFile = myFileManager.LoadFile(origDataFile, CommonParameters);
var searchModes = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = ProteinDbLoader.LoadProteinFasta(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\hela_snip_for_unitTest.fasta"), true, DecoyType.Reverse, false, ProteinDbLoader.UniprotAccessionRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotGeneNameRegex,
ProteinDbLoader.UniprotOrganismRegex, out var dbErrors, -1);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML", CommonParameters).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null, proteinList, searchModes, CommonParameters, new List <string>()).Run();
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(allPsmsArray.Where(p => p != null).ToList(), 1, CommonParameters, new List <string>()).Run());
var nonNullPsms = allPsmsArray.Where(p => p != null).ToList();
var nonNullPsmsOriginalCopy = allPsmsArray.Where(p => p != null).ToList();
var maxScore = nonNullPsms.Select(n => n.Score).Max();
PeptideSpectralMatch maxScorePsm = nonNullPsms.Where(n => n.Score == maxScore).First();
Dictionary <string, int> sequenceToPsmCount = new Dictionary <string, int>();
List <string> sequences = new List <string>();
foreach (PeptideSpectralMatch psm in nonNullPsms)
{
var ss = psm.BestMatchingPeptides.Select(b => b.Peptide.FullSequence).ToList();
sequences.Add(String.Join("|", ss));
}
var s = sequences.GroupBy(i => i);
foreach (var grp in s)
{
sequenceToPsmCount.Add(grp.Key, grp.Count());
}
Dictionary <string, Dictionary <int, Tuple <double, double> > > fileSpecificRetTimeHI_behavior = new Dictionary <string, Dictionary <int, Tuple <double, double> > >();
Dictionary <string, Dictionary <int, Tuple <double, double> > > fileSpecificRetTemHI_behaviorModifiedPeptides = new Dictionary <string, Dictionary <int, Tuple <double, double> > >();
//average hydrophobicity, standard deviation hydrophobicity
Tuple <double, double> at = new Tuple <double, double>(33.0, 1.0);
Dictionary <int, Tuple <double, double> > HI_Time_avg_dev = new Dictionary <int, Tuple <double, double> >
{
{ 154, at }
};
fileSpecificRetTimeHI_behavior.Add(@"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML", HI_Time_avg_dev);
string[] trainingVariables = new[] { "HydrophobicityZScore", "Intensity", "ScanPrecursorCharge", "DeltaScore", "Notch", "PsmCount", "ModsCount", "MissedCleavagesCount", "Ambiguity", "LongestFragmentIonSeries", "IsVariantPeptide" };
int chargeStateMode = 4;
var(notch, pwsm) = maxScorePsm.BestMatchingPeptides.First();
var maxPsmData = PEP_Analysis.CreateOnePsmDataEntry(maxScorePsm, sequenceToPsmCount, fileSpecificRetTimeHI_behavior, fileSpecificRetTemHI_behaviorModifiedPeptides, chargeStateMode, pwsm, trainingVariables, notch, !pwsm.Protein.IsDecoy);
Assert.That(maxScorePsm.PeptidesToMatchingFragments.Count - 1, Is.EqualTo(maxPsmData.Ambiguity));
Assert.That(maxScorePsm.DeltaScore, Is.EqualTo(maxPsmData.DeltaScore).Within(0.05));
Assert.That((float)(maxScorePsm.Score - (int)maxScorePsm.Score), Is.EqualTo(maxPsmData.Intensity).Within(0.05));
Assert.That(maxPsmData.HydrophobicityZScore, Is.EqualTo(5.170955).Within(0.05));
Assert.That(maxScorePsm.BestMatchingPeptides.Select(p => p.Peptide).First().MissedCleavages, Is.EqualTo(maxPsmData.MissedCleavagesCount));
Assert.That(maxScorePsm.BestMatchingPeptides.Select(p => p.Peptide).First().AllModsOneIsNterminus.Values.Count(), Is.EqualTo(maxPsmData.ModsCount));
Assert.That(maxScorePsm.Notch ?? 0, Is.EqualTo(maxPsmData.Notch));
Assert.That(maxScorePsm.PsmCount, Is.EqualTo(maxPsmData.PsmCount));
Assert.That(-Math.Abs(chargeStateMode - maxScorePsm.ScanPrecursorCharge), Is.EqualTo(maxPsmData.PrecursorChargeDiffToMode));
Assert.AreEqual((float)0, maxPsmData.IsVariantPeptide);
PEP_Analysis.ComputePEPValuesForAllPSMsGeneric(nonNullPsms);
int trueCount = 0;
foreach (var item in allPsmsArray.Where(p => p != null))
{
var b = item.FdrInfo.PEP;
if (b >= 0.5)
{
trueCount++;
}
}
List <PeptideSpectralMatch> moreNonNullPSMs = new List <PeptideSpectralMatch>();
for (int i = 0; i < 3; i++)
{
foreach (PeptideSpectralMatch psm in nonNullPsms)
{
moreNonNullPSMs.Add(psm);
}
}
string expectedMetrics = "************************************************************\r\n* Metrics for Determination of PEP Using Binary Classification \r\n" +
"*-----------------------------------------------------------\r\n* Accuracy: 1\r\n* Area Under Curve: 1\r\n* Area under Precision recall Curve: 1\r\n* F1Score: 1\r\n" +
"* LogLoss: 2.60551851621861E-10\r\n* LogLossReduction: 0.999999999599165\r\n* PositivePrecision: 1\r\n* PositiveRecall: 1\r\n* NegativePrecision: 1\r\n" +
"* NegativeRecall: 1\r\n* Count of Ambiguous Peptides Removed: 0\r\n************************************************************\r\n";
string metrics = PEP_Analysis.ComputePEPValuesForAllPSMsGeneric(moreNonNullPSMs);
Assert.AreEqual(expectedMetrics, metrics);
Assert.GreaterOrEqual(32, trueCount);
//Test Variant Peptide as Input is identified as such as part of PEP calculation input much of the next several lines simply necessry to create a psm.
var anMzSpectrum = new MzSpectrum(new double[] { 1, 1 }, new double[] { 2, 2 }, true);
Ms2ScanWithSpecificMass scan = new Ms2ScanWithSpecificMass(new MsDataScan(anMzSpectrum, 1, 1, true, Polarity.Negative, 2, null, "", MZAnalyzerType.Orbitrap, 2, null, null, null), 1, 1, "path", new CommonParameters());
Protein variantProtein = new Protein("MPEPPPTIDE", "protein3", sequenceVariations: new List <SequenceVariation> {
new SequenceVariation(4, 6, "PPP", "P", @"1\t50000000\t.\tA\tG\t.\tPASS\tANN=G||||||||||||||||\tGT:AD:DP\t1/1:30,30:30", null)
});
PeptideWithSetModifications varPep = variantProtein.GetVariantProteins().SelectMany(p => p.Digest(CommonParameters.DigestionParams, null, null)).FirstOrDefault();
PeptideSpectralMatch variantPSM = new PeptideSpectralMatch(varPep, 0, maxScorePsm.Score, maxScorePsm.ScanIndex, scan, new DigestionParams(), null);
sequenceToPsmCount = new Dictionary <string, int>();
sequences = new List <string>();
nonNullPsms.Add(variantPSM);
foreach (PeptideSpectralMatch psm in nonNullPsms)
{
var ss = psm.BestMatchingPeptides.Select(b => b.Peptide.FullSequence).ToList();
sequences.Add(String.Join("|", ss));
}
s = sequences.GroupBy(i => i);
foreach (var grp in s)
{
sequenceToPsmCount.Add(grp.Key, grp.Count());
}
var(vnotch, vpwsm) = variantPSM.BestMatchingPeptides.First();
PsmData variantPsmData = PEP_Analysis.CreateOnePsmDataEntry(variantPSM, sequenceToPsmCount, fileSpecificRetTimeHI_behavior, fileSpecificRetTemHI_behaviorModifiedPeptides, chargeStateMode, vpwsm, trainingVariables, vnotch, !maxScorePsm.IsDecoy);
Assert.AreEqual((float)1, variantPsmData.IsVariantPeptide);
}
private (List <PeptideSpectralMatch>, DataPointAquisitionResults) GetDataAcquisitionResults(IMsDataFile <IMsDataScan <IMzSpectrum <IMzPeak> > > myMsDataFile, string currentDataFile, List <ModificationWithMass> variableModifications, List <ModificationWithMass> fixedModifications, List <Protein> proteinList, string taskId, ICommonParameters combinedParameters, Tolerance initPrecTol, Tolerance initProdTol)
{
var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(currentDataFile);
MassDiffAcceptor searchMode;
if (initPrecTol is PpmTolerance)
{
searchMode = new SinglePpmAroundZeroSearchMode(initPrecTol.Value);
}
else
{
searchMode = new SingleAbsoluteAroundZeroSearchMode(initPrecTol.Value);
}
FragmentTypes fragmentTypesForCalibration = FragmentTypes.None;
if (combinedParameters.BIons)
{
fragmentTypesForCalibration = fragmentTypesForCalibration | FragmentTypes.b;
}
if (combinedParameters.YIons)
{
fragmentTypesForCalibration = fragmentTypesForCalibration | FragmentTypes.y;
}
if (combinedParameters.CIons)
{
fragmentTypesForCalibration = fragmentTypesForCalibration | FragmentTypes.c;
}
if (combinedParameters.ZdotIons)
{
fragmentTypesForCalibration = fragmentTypesForCalibration | FragmentTypes.zdot;
}
var listOfSortedms2Scans = GetMs2Scans(myMsDataFile, currentDataFile, combinedParameters.DoPrecursorDeconvolution, combinedParameters.UseProvidedPrecursorInfo, combinedParameters.DeconvolutionIntensityRatio, combinedParameters.DeconvolutionMaxAssumedChargeState, combinedParameters.DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
List <ProductType> lp = new List <ProductType>();
if (combinedParameters.BIons)
{
lp.Add(ProductType.B);
}
if (combinedParameters.YIons)
{
lp.Add(ProductType.Y);
}
if (combinedParameters.CIons)
{
lp.Add(ProductType.C);
}
if (combinedParameters.ZdotIons)
{
lp.Add(ProductType.Zdot);
}
Log("Searching with searchMode: " + searchMode, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
});
Log("Searching with productMassTolerance: " + initProdTol, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
});
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, proteinList, lp, searchMode, false, combinedParameters, initProdTol, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
List <PeptideSpectralMatch> allPsms = allPsmsArray.ToList();
Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> > compactPeptideToProteinPeptideMatching = ((SequencesToActualProteinPeptidesEngineResults) new SequencesToActualProteinPeptidesEngine(allPsms, proteinList, fixedModifications, variableModifications, lp, new List <IDigestionParams> {
combinedParameters.DigestionParams
}, combinedParameters.ReportAllAmbiguity, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run()).CompactPeptideToProteinPeptideMatching;
foreach (var huh in allPsms)
{
if (huh != null)
{
huh.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching);
}
}
allPsms = allPsms.Where(b => b != null).OrderByDescending(b => b.Score).ThenBy(b => b.PeptideMonisotopicMass.HasValue ? Math.Abs(b.ScanPrecursorMass - b.PeptideMonisotopicMass.Value) : double.MaxValue).GroupBy(b => (b.FullFilePath, b.ScanNumber, b.PeptideMonisotopicMass)).Select(b => b.First()).ToList();
new FdrAnalysisEngine(allPsms, searchMode.NumNotches, false, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
List <PeptideSpectralMatch> goodIdentifications = allPsms.Where(b => b.FdrInfo.QValueNotch < 0.01 && !b.IsDecoy && b.FullSequence != null).ToList();
if (!goodIdentifications.Any())
{
Warn("No PSMs below 1% FDR observed!");
return(new List <PeptideSpectralMatch>(), null);
}
var dissociationTypes = MetaMorpheusEngine.DetermineDissociationType(lp);
foreach (var psm in allPsms)
{
var theScan = myMsDataFile.GetOneBasedScan(psm.ScanNumber);
double thePrecursorMass = psm.ScanPrecursorMass;
foreach (var huh in lp)
{
var ionMasses = psm.CompactPeptides.First().Key.ProductMassesMightHaveDuplicatesAndNaNs(new List <ProductType> {
huh
});
Array.Sort(ionMasses);
List <double> matchedIonMassesList = new List <double>();
List <double> productMassErrorDaList = new List <double>();
List <double> productMassErrorPpmList = new List <double>();
LocalizationEngine.MatchIons(theScan, initProdTol, ionMasses, matchedIonMassesList, productMassErrorDaList, productMassErrorPpmList, thePrecursorMass, dissociationTypes, false);
double[] matchedIonMassesOnlyMatches = matchedIonMassesList.ToArray();
psm.MatchedIonDictOnlyMatches.Add(huh, matchedIonMassesOnlyMatches);
psm.ProductMassErrorDa.Add(huh, productMassErrorDaList.ToArray());
psm.ProductMassErrorPpm.Add(huh, productMassErrorPpmList.ToArray());
}
}
DataPointAquisitionResults currentResult = (DataPointAquisitionResults) new DataPointAcquisitionEngine(
goodIdentifications,
myMsDataFile,
initPrecTol,
initProdTol,
CalibrationParameters.NumFragmentsNeededForEveryIdentification,
CalibrationParameters.MinMS1IsotopicPeaksNeededForConfirmedIdentification,
CalibrationParameters.MinMS2IsotopicPeaksNeededForConfirmedIdentification,
fragmentTypesForCalibration,
new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
return(goodIdentifications, currentResult);
}
public static void TestComputePEPValueTopDown()
{
//just making sure that topdown data goes through the pep calculator without crashing.
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(protease: "top-down"),
scoreCutoff: 1,
assumeOrphanPeaksAreZ1Fragments: false);
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
List <Protein> proteinList = ProteinDbLoader.LoadProteinFasta(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\HeLaFakeTopDown.fasta"), true, DecoyType.Reverse, false, ProteinDbLoader.UniprotAccessionRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotFullNameRegex, ProteinDbLoader.UniprotGeneNameRegex,
ProteinDbLoader.UniprotOrganismRegex, out var dbErrors, -1);
var origDataFile = Path.Combine(TestContext.CurrentContext.TestDirectory, @"TestData\TaGe_SA_HeLa_04_subset_longestSeq.mzML");
MyFileManager myFileManager = new MyFileManager(true);
var myMsDataFile = myFileManager.LoadFile(origDataFile, CommonParameters);
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null, proteinList, searchMode, CommonParameters, new List <string>()).Run();
var nonNullPsms = allPsmsArray.Where(p => p != null).ToList();
List <PeptideSpectralMatch> moreNonNullPSMs = new List <PeptideSpectralMatch>();
int reps = 3;
for (int i = 0; i < reps; i++)
{
foreach (PeptideSpectralMatch psm in nonNullPsms)
{
moreNonNullPSMs.Add(psm);
}
}
FdrAnalysisResults fdrResultsClassicDelta = (FdrAnalysisResults)(new FdrAnalysisEngine(moreNonNullPSMs.Where(p => p != null).ToList(), 1, CommonParameters, new List <string>()).Run());
var maxScore = nonNullPsms.Select(n => n.Score).Max();
PeptideSpectralMatch maxScorePsm = nonNullPsms.Where(n => n.Score == maxScore).First();
Dictionary <string, int> sequenceToPsmCount = new Dictionary <string, int>();
List <string> sequences = new List <string>();
foreach (PeptideSpectralMatch psm in nonNullPsms)
{
var ss = psm.BestMatchingPeptides.Select(b => b.Peptide.FullSequence).ToList();
sequences.Add(String.Join("|", ss));
}
var s = sequences.GroupBy(i => i);
foreach (var grp in s)
{
sequenceToPsmCount.Add(grp.Key, grp.Count());
}
Dictionary <string, Dictionary <int, Tuple <double, double> > > fileSpecificRetTimeHI_behavior = new Dictionary <string, Dictionary <int, Tuple <double, double> > >();
Dictionary <string, Dictionary <int, Tuple <double, double> > > fileSpecificRetTemHI_behaviorModifiedPeptides = new Dictionary <string, Dictionary <int, Tuple <double, double> > >();
string[] trainingVariables = PsmData.trainingInfos["topDown"];
int chargeStateMode = 4;
var(notch, pwsm) = maxScorePsm.BestMatchingPeptides.First();
var maxPsmData = PEP_Analysis.CreateOnePsmDataEntry(maxScorePsm, sequenceToPsmCount, fileSpecificRetTimeHI_behavior, fileSpecificRetTemHI_behaviorModifiedPeptides, chargeStateMode, pwsm, trainingVariables, notch, !pwsm.Protein.IsDecoy);
Assert.That(maxScorePsm.PeptidesToMatchingFragments.Count - 1, Is.EqualTo(maxPsmData.Ambiguity));
Assert.That(maxScorePsm.DeltaScore, Is.EqualTo(maxPsmData.DeltaScore).Within(0.05));
Assert.That((float)(maxScorePsm.Score - (int)maxScorePsm.Score), Is.EqualTo(maxPsmData.Intensity).Within(0.05));
Assert.AreEqual(maxPsmData.HydrophobicityZScore, float.NaN);
Assert.That(maxScorePsm.BestMatchingPeptides.Select(p => p.Peptide).First().MissedCleavages, Is.EqualTo(maxPsmData.MissedCleavagesCount));
Assert.That(maxScorePsm.BestMatchingPeptides.Select(p => p.Peptide).First().AllModsOneIsNterminus.Values.Count(), Is.EqualTo(maxPsmData.ModsCount));
Assert.That(maxScorePsm.Notch ?? 0, Is.EqualTo(maxPsmData.Notch));
Assert.That(maxScorePsm.PsmCount, Is.EqualTo(maxPsmData.PsmCount * reps));
Assert.That(-Math.Abs(chargeStateMode - maxScorePsm.ScanPrecursorCharge), Is.EqualTo(maxPsmData.PrecursorChargeDiffToMode));
Assert.AreEqual((float)0, maxPsmData.IsVariantPeptide);
}
public static void TestModificationAnalysis()
{
IScan scan = new ThisTestScan();
ModificationMotif.TryGetMotif("N", out ModificationMotif motif1);
Modification mod1 = new Modification(_originalId: "mod1", _modificationType: "myModType", _target: motif1, _locationRestriction: "Anywhere.", _monoisotopicMass: 10);
ModificationMotif.TryGetMotif("L", out ModificationMotif motif2);
Modification mod2 = new Modification(_originalId: "mod2", _modificationType: "myModType", _target: motif2, _locationRestriction: "Anywhere.", _monoisotopicMass: 10);
IDictionary <int, List <Modification> > oneBasedModifications = new Dictionary <int, List <Modification> >
{
{ 2, new List <Modification> {
mod1
} },
{ 5, new List <Modification> {
mod2
} },
{ 7, new List <Modification> {
mod1
} },
};
Protein protein1 = new Protein("MNLDLDNDL", "prot1", oneBasedModifications: oneBasedModifications);
Dictionary <int, Modification> allModsOneIsNterminus1 = new Dictionary <int, Modification>
{
{ 2, mod1 },
};
PeptideWithSetModifications pwsm1 = new PeptideWithSetModifications(protein1, new DigestionParams(), 2, 9, CleavageSpecificity.Unknown, null, 0, allModsOneIsNterminus1, 0);
Dictionary <int, Modification> allModsOneIsNterminus2 = new Dictionary <int, Modification>
{
{ 2, mod1 },
{ 7, mod1 },
};
PeptideWithSetModifications pwsm2 = new PeptideWithSetModifications(protein1, new DigestionParams(), 2, 9, CleavageSpecificity.Unknown, null, 0, allModsOneIsNterminus2, 0);
Dictionary <int, Modification> allModsOneIsNterminus3 = new Dictionary <int, Modification>
{
{ 7, mod1 },
};
PeptideWithSetModifications pwsm3 = new PeptideWithSetModifications(protein1, new DigestionParams(), 2, 9, CleavageSpecificity.Unknown, null, 0, allModsOneIsNterminus3, 0);
Dictionary <int, Modification> allModsOneIsNterminus4 = new Dictionary <int, Modification>
{
{ 8, mod1 },
};
PeptideWithSetModifications pwsm4 = new PeptideWithSetModifications(protein1, new DigestionParams(), 1, 9, CleavageSpecificity.Unknown, null, 0, allModsOneIsNterminus4, 0);
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(
maxMissedCleavages: 0,
minPeptideLength: 1,
maxModificationIsoforms: int.MaxValue),
scoreCutoff: 1);
var newPsms = new List <PeptideSpectralMatch>
{
new PeptideSpectralMatch(pwsm1, 0, 10, 0, scan, CommonParameters.DigestionParams, new List <MatchedFragmentIon>()),
new PeptideSpectralMatch(pwsm1, 0, 10, 0, scan, CommonParameters.DigestionParams, new List <MatchedFragmentIon>()),
new PeptideSpectralMatch(pwsm2, 0, 10, 0, scan, CommonParameters.DigestionParams, new List <MatchedFragmentIon>()),
new PeptideSpectralMatch(pwsm3, 0, 10, 0, scan, CommonParameters.DigestionParams, new List <MatchedFragmentIon>()),
new PeptideSpectralMatch(pwsm4, 0, 10, 0, scan, CommonParameters.DigestionParams, new List <MatchedFragmentIon>()),
};
foreach (var psm in newPsms)
{
psm.ResolveAllAmbiguities();
}
MassDiffAcceptor searchMode = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = new List <Protein> {
protein1
};
FdrAnalysisEngine fdrAnalysisEngine = new FdrAnalysisEngine(newPsms, searchMode.NumNotches, CommonParameters, new List <string>());
fdrAnalysisEngine.Run();
ModificationAnalysisEngine modificationAnalysisEngine = new ModificationAnalysisEngine(newPsms, new CommonParameters(), new List <string>());
var res = (ModificationAnalysisResults)modificationAnalysisEngine.Run();
Assert.AreEqual(2, res.CountOfEachModSeenOnProteins.Count());
Assert.AreEqual(2, res.CountOfEachModSeenOnProteins[mod1.IdWithMotif]);
Assert.AreEqual(1, res.CountOfEachModSeenOnProteins[mod2.IdWithMotif]);
Assert.AreEqual(1, res.CountOfModsSeenAndLocalized.Count());
Assert.AreEqual(2, res.CountOfModsSeenAndLocalized[mod1.IdWithMotif]);
Assert.AreEqual(0, res.CountOfAmbiguousButLocalizedModsSeen.Count());
Assert.AreEqual(0, res.CountOfUnlocalizedMods.Count());
Assert.AreEqual(0, res.CountOfUnlocalizedFormulas.Count());
}
public static void TestModificationAnalysis()
{
IScan scan = new ThisTestScan();
ModificationMotif.TryGetMotif("N", out ModificationMotif motif1);
ModificationWithMass mod1 = new ModificationWithMass("mod1", null, motif1, TerminusLocalization.Any, 10);
ModificationMotif.TryGetMotif("L", out ModificationMotif motif2);
ModificationWithMass mod2 = new ModificationWithMass("mod2", null, motif2, TerminusLocalization.Any, 10);
IDictionary <int, List <Modification> > oneBasedModifications = new Dictionary <int, List <Modification> >
{
{ 2, new List <Modification> {
mod1
} },
{ 5, new List <Modification> {
mod2
} },
{ 7, new List <Modification> {
mod1
} },
};
Protein protein1 = new Protein("MNLDLDNDL", "prot1", oneBasedModifications: oneBasedModifications);
Dictionary <int, ModificationWithMass> allModsOneIsNterminus1 = new Dictionary <int, ModificationWithMass>
{
{ 2, mod1 },
};
PeptideWithSetModifications pwsm1 = new PeptideWithSetModifications(0, protein1, 2, 9, allModsOneIsNterminus1);
CompactPeptideBase pep1 = new CompactPeptide(pwsm1, TerminusType.None);
Dictionary <int, ModificationWithMass> allModsOneIsNterminus2 = new Dictionary <int, ModificationWithMass>
{
{ 2, mod1 },
{ 7, mod1 },
};
PeptideWithSetModifications pwsm2 = new PeptideWithSetModifications(0, protein1, 2, 9, allModsOneIsNterminus2);
CompactPeptideBase pep2 = new CompactPeptide(pwsm2, TerminusType.None);
Dictionary <int, ModificationWithMass> allModsOneIsNterminus3 = new Dictionary <int, ModificationWithMass>
{
{ 7, mod1 },
};
PeptideWithSetModifications pwsm3 = new PeptideWithSetModifications(0, protein1, 2, 9, allModsOneIsNterminus3);
CompactPeptideBase pep3 = new CompactPeptide(pwsm3, TerminusType.None);
Dictionary <int, ModificationWithMass> allModsOneIsNterminus4 = new Dictionary <int, ModificationWithMass>
{
{ 8, mod1 },
};
PeptideWithSetModifications pwsm4 = new PeptideWithSetModifications(0, protein1, 1, 9, allModsOneIsNterminus4);
CompactPeptideBase pep4 = new CompactPeptide(pwsm4, TerminusType.None);
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(
maxMissedCleavages: 0,
minPeptideLength: 1,
maxModificationIsoforms: int.MaxValue),
scoreCutoff: 1);
var newPsms = new List <PeptideSpectralMatch>
{
new PeptideSpectralMatch(pep1, 0, 10, 0, scan, CommonParameters.DigestionParams),
new PeptideSpectralMatch(pep1, 0, 10, 0, scan, CommonParameters.DigestionParams),
new PeptideSpectralMatch(pep2, 0, 10, 0, scan, CommonParameters.DigestionParams),
new PeptideSpectralMatch(pep3, 0, 10, 0, scan, CommonParameters.DigestionParams),
new PeptideSpectralMatch(pep4, 0, 10, 0, scan, CommonParameters.DigestionParams),
};
MassDiffAcceptor searchMode = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = new List <Protein> {
protein1
};
SequencesToActualProteinPeptidesEngine sequencesToActualProteinPeptidesEngine = new SequencesToActualProteinPeptidesEngine
(newPsms, proteinList, new List <ModificationWithMass>(), new List <ModificationWithMass>(), new List <ProductType>
{
ProductType.B, ProductType.Y
}, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, CommonParameters, new List <string>());
var nice = (SequencesToActualProteinPeptidesEngineResults)sequencesToActualProteinPeptidesEngine.Run();
foreach (var psm in newPsms)
{
psm.MatchToProteinLinkedPeptides(nice.CompactPeptideToProteinPeptideMatching);
}
FdrAnalysisEngine fdrAnalysisEngine = new FdrAnalysisEngine(newPsms, searchMode.NumNotches, CommonParameters, new List <string>());
fdrAnalysisEngine.Run();
ModificationAnalysisEngine modificationAnalysisEngine = new ModificationAnalysisEngine(newPsms, new CommonParameters(), new List <string>());
var res = (ModificationAnalysisResults)modificationAnalysisEngine.Run();
Assert.AreEqual(2, res.AllModsOnProteins.Count());
Assert.AreEqual(2, res.AllModsOnProteins[mod1.id]);
Assert.AreEqual(1, res.AllModsOnProteins[mod2.id]);
Assert.AreEqual(1, res.ModsSeenAndLocalized.Count());
Assert.AreEqual(2, res.ModsSeenAndLocalized[mod1.id]);
Assert.AreEqual(0, res.AmbiguousButLocalizedModsSeen.Count());
Assert.AreEqual(0, res.UnlocalizedMods.Count());
Assert.AreEqual(0, res.UnlocalizedFormulas.Count());
}
public static void TestModificationAnalysisWithNonLocalizedPtms()
{
IScan scan = new ThisTestScan();
ModificationMotif.TryGetMotif("N", out ModificationMotif motif1);
Modification mod1 = new Modification(_originalId: "mod1", _modificationType: "mt", _target: motif1, _locationRestriction: "Anywhere.", _monoisotopicMass: 10, _neutralLosses: new Dictionary <DissociationType, List <double> > {
{ MassSpectrometry.DissociationType.AnyActivationType, new List <double> {
10
} }
});
IDictionary <int, List <Modification> > oneBasedModifications = new Dictionary <int, List <Modification> >
{
{ 2, new List <Modification> {
mod1
} },
{ 7, new List <Modification> {
mod1
} },
};
Protein protein1 = new Protein("MNLDLDNDL", "prot1", oneBasedModifications: oneBasedModifications);
Dictionary <int, Modification> allModsOneIsNterminus1 = new Dictionary <int, Modification>
{
{ 2, mod1 },
};
PeptideWithSetModifications pwsm1 = new PeptideWithSetModifications(protein1, new DigestionParams(), 2, 9, CleavageSpecificity.Unknown, null, 0, allModsOneIsNterminus1, 0);
Dictionary <int, Modification> allModsOneIsNterminus3 = new Dictionary <int, Modification>
{
{ 7, mod1 },
};
PeptideWithSetModifications pwsm2 = new PeptideWithSetModifications(protein1, new DigestionParams(), 2, 9, CleavageSpecificity.Unknown, null, 0, allModsOneIsNterminus3, 0);
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams(maxMissedCleavages: 0, minPeptideLength: 1), scoreCutoff: 1);
PeptideSpectralMatch myPsm = new PeptideSpectralMatch(pwsm1, 0, 10, 0, scan, new DigestionParams(), new List <MatchedFragmentIon>());
myPsm.AddOrReplace(pwsm2, 10, 0, true, new List <MatchedFragmentIon>(), 0);
myPsm.ResolveAllAmbiguities();
MassDiffAcceptor searchMode = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = new List <Protein> {
protein1
};
FdrAnalysisEngine fdrAnalysisEngine = new FdrAnalysisEngine(new List <PeptideSpectralMatch> {
myPsm
}, searchMode.NumNotches, CommonParameters, new List <string>());
fdrAnalysisEngine.Run();
ModificationAnalysisEngine modificationAnalysisEngine = new ModificationAnalysisEngine(new List <PeptideSpectralMatch> {
myPsm
}, new CommonParameters(), new List <string>());
var res = (ModificationAnalysisResults)modificationAnalysisEngine.Run();
Assert.AreEqual(1, res.CountOfEachModSeenOnProteins.Count());
Assert.AreEqual(2, res.CountOfEachModSeenOnProteins[mod1.IdWithMotif]);
Assert.AreEqual(0, res.CountOfModsSeenAndLocalized.Count());
Assert.AreEqual(0, res.CountOfAmbiguousButLocalizedModsSeen.Count);
Assert.AreEqual(1, res.CountOfUnlocalizedMods[mod1.IdWithMotif]); // Saw it, but not sure where!
Assert.AreEqual(0, res.CountOfUnlocalizedFormulas.Count());
}
public static void TestModificationAnalysisWithNonLocalizedPtms()
{
IScan scan = new ThisTestScan();
ModificationMotif.TryGetMotif("N", out ModificationMotif motif1);
ModificationWithMass mod1 = new ModificationWithMass("mod1", "mt", motif1, TerminusLocalization.Any, 10, neutralLosses: new List <double> {
10
});
IDictionary <int, List <Modification> > oneBasedModifications = new Dictionary <int, List <Modification> >
{
{ 2, new List <Modification> {
mod1
} },
{ 7, new List <Modification> {
mod1
} },
};
Protein protein1 = new Protein("MNLDLDNDL", "prot1", oneBasedModifications: oneBasedModifications);
Dictionary <int, ModificationWithMass> allModsOneIsNterminus1 = new Dictionary <int, ModificationWithMass>
{
{ 2, mod1 },
};
PeptideWithSetModifications pwsm1 = new PeptideWithSetModifications(0, protein1, 2, 9, allModsOneIsNterminus1);
CompactPeptideBase pep1 = new CompactPeptide(pwsm1, TerminusType.None);
Dictionary <int, ModificationWithMass> allModsOneIsNterminus3 = new Dictionary <int, ModificationWithMass>
{
{ 7, mod1 },
};
PeptideWithSetModifications pwsm3 = new PeptideWithSetModifications(0, protein1, 2, 9, allModsOneIsNterminus3);
CompactPeptideBase pep3 = new CompactPeptide(pwsm3, TerminusType.None);
var newPsms = new List <PeptideSpectralMatch>
{
new PeptideSpectralMatch(pep1, 0, 10, 0, scan),
new PeptideSpectralMatch(pep3, 0, 10, 0, scan),
};
MassDiffAcceptor searchMode = new SinglePpmAroundZeroSearchMode(5);
List <Protein> proteinList = new List <Protein> {
protein1
};
CommonParameters CommonParameters = new CommonParameters
{
DigestionParams = new DigestionParams
{
MinPeptideLength = null,
MaxMissedCleavages = 0,
MaxModificationIsoforms = int.MaxValue
},
ConserveMemory = false,
ScoreCutoff = 1,
};
SequencesToActualProteinPeptidesEngine sequencesToActualProteinPeptidesEngine = new SequencesToActualProteinPeptidesEngine(newPsms, proteinList, new List <ModificationWithMass>(), new List <ModificationWithMass>(), new List <ProductType> {
ProductType.B, ProductType.Y
}, new List <IDigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, new List <string>());
var nice = (SequencesToActualProteinPeptidesEngineResults)sequencesToActualProteinPeptidesEngine.Run();
foreach (var psm in newPsms)
{
psm.MatchToProteinLinkedPeptides(nice.CompactPeptideToProteinPeptideMatching);
}
Assert.AreEqual(2, nice.CompactPeptideToProteinPeptideMatching[pep1].Count);
FdrAnalysisEngine fdrAnalysisEngine = new FdrAnalysisEngine(newPsms, searchMode.NumNotches, false, new List <string>());
fdrAnalysisEngine.Run();
ModificationAnalysisEngine modificationAnalysisEngine = new ModificationAnalysisEngine(newPsms, new List <string>());
var res = (ModificationAnalysisResults)modificationAnalysisEngine.Run();
Assert.AreEqual(1, res.AllModsOnProteins.Count());
Assert.AreEqual(2, res.AllModsOnProteins[mod1.id]);
Assert.AreEqual(0, res.ModsSeenAndLocalized.Count());
Assert.AreEqual(0, res.AmbiguousButLocalizedModsSeen.Count);
Assert.AreEqual(1, res.UnlocalizedMods[mod1.id]); // Saw it, but not sure where!
Assert.AreEqual(0, res.UnlocalizedFormulas.Count());
}
public static void TestResolveAmbiguities()
{
CommonParameters CommonParameters = new CommonParameters
{
DigestionParams = new DigestionParams
{
Protease = new Protease("Custom Protease", new List <string> {
"K"
}, new List <string>(), TerminusType.C, CleavageSpecificity.Full, null, null, null),
MinPeptideLength = null,
},
ConserveMemory = false,
ScoreCutoff = 1,
ReportAllAmbiguity = false
};
var myMsDataFile = new TestDataFile();
var variableModifications = new List <ModificationWithMass>();
var fixedModifications = new List <ModificationWithMass>();
var proteinList = new List <Protein> {
new Protein("MNNKNKNKQQQ", "Prot1", "organism", null, null, null, null, null, true), new Protein("MNNNKQQQ", "Prot2")
};
var searchModes = new SinglePpmAroundZeroSearchMode(5);
bool DoPrecursorDeconvolution = true;
bool UseProvidedPrecursorInfo = true;
double DeconvolutionIntensityRatio = 4;
int DeconvolutionMaxAssumedChargeState = 10;
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, DoPrecursorDeconvolution, UseProvidedPrecursorInfo, DeconvolutionIntensityRatio, DeconvolutionMaxAssumedChargeState, DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArrayt = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
PeptideSpectralMatch[] allPsmsArrayf = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArrayt, listOfSortedms2Scans, variableModifications, fixedModifications, proteinList, new List <ProductType> {
ProductType.B, ProductType.Y
}, searchModes, false, CommonParameters, CommonParameters.ProductMassTolerance, new List <string>()).Run();
new ClassicSearchEngine(allPsmsArrayf, listOfSortedms2Scans, variableModifications, fixedModifications, proteinList, new List <ProductType> {
ProductType.B, ProductType.Y
}, searchModes, false, CommonParameters, CommonParameters.ProductMassTolerance, new List <string>()).Run();
var haht = (SequencesToActualProteinPeptidesEngineResults) new SequencesToActualProteinPeptidesEngine(new List <PeptideSpectralMatch> {
allPsmsArrayt[0]
}, proteinList, fixedModifications, variableModifications, new List <ProductType> {
ProductType.B, ProductType.Y
}, new List <IDigestionParams> {
CommonParameters.DigestionParams
}, true, new List <string>()).Run();
var hahf = (SequencesToActualProteinPeptidesEngineResults) new SequencesToActualProteinPeptidesEngine(new List <PeptideSpectralMatch> {
allPsmsArrayf[0]
}, proteinList, fixedModifications, variableModifications, new List <ProductType> {
ProductType.B, ProductType.Y
}, new List <IDigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, new List <string>()).Run();
foreach (var huh in allPsmsArrayt)
{
if (huh != null)
{
huh.MatchToProteinLinkedPeptides(haht.CompactPeptideToProteinPeptideMatching);
}
}
foreach (var huh in allPsmsArrayf)
{
if (huh != null)
{
huh.MatchToProteinLinkedPeptides(hahf.CompactPeptideToProteinPeptideMatching);
}
}
Assert.AreEqual("QQQ", allPsmsArrayt[0].BaseSequence);
Assert.AreEqual("QQQ", allPsmsArrayf[0].BaseSequence);
Assert.IsTrue(allPsmsArrayt[0].ProteinLength == null);
Assert.IsTrue(allPsmsArrayf[0].ProteinLength == 8);
Assert.IsTrue(allPsmsArrayt[0].OneBasedStartResidueInProtein == null);
Assert.IsTrue(allPsmsArrayf[0].OneBasedStartResidueInProtein == 6);
}
private static Tuple <List <PeptideSpectralMatch>, Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> >, MassDiffAcceptor, bool, CompactPeptideBase, CompactPeptideBase> GetInfo(bool localizeable)
{
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams(maxMissedCleavages: 0, minPeptideLength: 1, maxModificationIsoforms: 2, initiatorMethionineBehavior: InitiatorMethionineBehavior.Retain, maxModsForPeptides: 1), scoreCutoff: 1);
// Alanine = Glycine + CH2
Protein protein1 = new Protein("MA", "protein1");
Protein protein2 = new Protein("MG", "protein2");
Protein protein3;
double monoisotopicMass = Chemistry.ChemicalFormula.ParseFormula("CH2").MonoisotopicMass;
ModificationMotif.TryGetMotif("G", out ModificationMotif motif1);
ModificationMotif.TryGetMotif("A", out ModificationMotif motif2);
TerminusLocalization modificationSites = TerminusLocalization.Any;
List <ModificationWithMass> allKnownFixedModifications = new List <ModificationWithMass>
{
new ModificationWithMass("CH2 on Glycine", null, motif1, modificationSites, monoisotopicMass)
};
List <ModificationWithMass> variableModifications;
ModificationWithMass alanineMod = new ModificationWithMass("CH2 on Alanine", null, motif2, modificationSites, monoisotopicMass);
if (localizeable)
{
variableModifications = new List <ModificationWithMass>();
IDictionary <int, List <Modification> > oneBasedModifications = new Dictionary <int, List <Modification> >
{
{ 2, new List <Modification> {
alanineMod
} }
};
protein3 = new Protein("MA", "protein3", oneBasedModifications: oneBasedModifications);
}
else
{
variableModifications = new List <ModificationWithMass>();
variableModifications = new List <ModificationWithMass> {
alanineMod
};
protein3 = new Protein("MA", "protein3");
}
var pepWithSetModifications1 = protein1.Digest(CommonParameters.DigestionParams, allKnownFixedModifications, variableModifications).First();
var pepWithSetModifications2 = protein2.Digest(CommonParameters.DigestionParams, allKnownFixedModifications, variableModifications).First();
var pepWithSetModifications3 = protein3.Digest(CommonParameters.DigestionParams, allKnownFixedModifications, variableModifications).Last();
CompactPeptide compactPeptide1 = new CompactPeptide(pepWithSetModifications1, TerminusType.None);
CompactPeptide compactPeptideDuplicate = new CompactPeptide(pepWithSetModifications2, TerminusType.None);
Assert.AreEqual(compactPeptide1, compactPeptideDuplicate);
CompactPeptide compactPeptide2 = new CompactPeptide(pepWithSetModifications3, TerminusType.None);
string fullFilePath = null;
int precursorCharge = 0;
TestDataFile testDataFile = new TestDataFile();
MsDataScan mzLibScan = testDataFile.GetOneBasedScan(2);
Ms2ScanWithSpecificMass scan = new Ms2ScanWithSpecificMass(mzLibScan, 0, precursorCharge, fullFilePath);
int scanIndex = 0;
double score = 0;
int notch = 0;
PeptideSpectralMatch psm1 = new PeptideSpectralMatch(compactPeptide1, notch, score, scanIndex, scan, CommonParameters.DigestionParams);
psm1.SetFdrValues(0, 0, 0, 0, 0, 0, 0, 0, 0, false);
PeptideSpectralMatch psm2 = new PeptideSpectralMatch(compactPeptide1, notch, score, scanIndex, scan, CommonParameters.DigestionParams);
psm2.SetFdrValues(0, 0, 0, 0, 0, 0, 0, 0, 0, false);
PeptideSpectralMatch psm3 = new PeptideSpectralMatch(compactPeptide2, notch, score, scanIndex, scan, CommonParameters.DigestionParams);
psm3.SetFdrValues(0, 0, 0, 0, 0, 0, 0, 0, 0, false);
var newPsms = new List <PeptideSpectralMatch>
{
psm1,
psm2,
psm3
};
MassDiffAcceptor massDiffAcceptors = new SinglePpmAroundZeroSearchMode(5);
SequencesToActualProteinPeptidesEngine stappe = new SequencesToActualProteinPeptidesEngine(newPsms, new List <Protein> {
protein1, protein2, protein3
},
allKnownFixedModifications, variableModifications, new List <ProductType> {
ProductType.B, ProductType.Y
}, new List <DigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, CommonParameters, new List <string>());
var haha = (SequencesToActualProteinPeptidesEngineResults)stappe.Run();
var compactPeptideToProteinPeptideMatching = haha.CompactPeptideToProteinPeptideMatching;
Assert.AreEqual(2, compactPeptideToProteinPeptideMatching.Count);
psm1.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching);
bool noOneHitWonders = false;
return(new Tuple <List <PeptideSpectralMatch>, Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> >, MassDiffAcceptor, bool, CompactPeptideBase, CompactPeptideBase>
(
newPsms, compactPeptideToProteinPeptideMatching, massDiffAcceptors, noOneHitWonders, compactPeptide1, compactPeptide2
));
}
public static void TestMatchIonsOfAllChargesTopDown()
{
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(protease: "top-down"),
scoreCutoff: 1,
assumeOrphanPeaksAreZ1Fragments: false);
MetaMorpheusTask.DetermineAnalyteType(CommonParameters);
// test output file name (should be proteoform and not peptide)
Assert.That(GlobalVariables.AnalyteType == "Proteoform");
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var proteinList = new List <Protein>
{
new Protein("MPKVYSYQEVAEHNGPENFWIIIDDKVYDVSQFKDEHPGGDEIIMDLGGQDATESFVDIGHSDEALRLLKGLYIGDVDKTSERVSVEKVSTSENQSKGSGTLVVILAILMLGVAYYLLNE", "P40312")
};
var myMsDataFile = Mzml.LoadAllStaticData(Path.Combine(TestContext.CurrentContext.TestDirectory, @"TopDownTestData\slicedTDYeast.mzML"));
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
//search by new method of looking for all charges
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>(), true).Run();
var psm = allPsmsArray.Where(p => p != null).FirstOrDefault();
Assert.That(psm.MatchedFragmentIons.Count == 62);
//search by old method of looking for only one charge
PeptideSpectralMatch[] allPsmsArray_oneCharge = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ClassicSearchEngine(allPsmsArray_oneCharge, listOfSortedms2Scans, variableModifications, fixedModifications, null, null, null,
proteinList, searchMode, CommonParameters, null, null, new List <string>(), false).Run();
var psm_oneCharge = allPsmsArray_oneCharge.Where(p => p != null).FirstOrDefault();
Assert.That(psm_oneCharge.MatchedFragmentIons.Count == 47);
//compare 2 scores , they should have same integer but new search has a little higher score than old search
Assert.That(psm.Score > psm_oneCharge.Score);
Assert.AreEqual(Math.Truncate(psm.Score), 47);
Assert.AreEqual(Math.Truncate(psm_oneCharge.Score), 47);
//compare 2 results and evaluate the different matched ions
var peptideTheorProducts = new List <Product>();
var differences = psm.MatchedFragmentIons.Except(psm_oneCharge.MatchedFragmentIons);
psm.BestMatchingPeptides.First().Peptide.Fragment(CommonParameters.DissociationType, CommonParameters.DigestionParams.FragmentationTerminus, peptideTheorProducts);
foreach (var ion in differences)
{
foreach (var product in peptideTheorProducts)
{
if (product.Annotation.ToString().Equals(ion.NeutralTheoreticalProduct.Annotation.ToString()))
{
//to see if the different matched ions are qualified
Assert.That(CommonParameters.ProductMassTolerance.Within(ion.Mz.ToMass(ion.Charge), product.NeutralMass));
}
}
}
}
public static void TestAnalysisEngineTests()
{
List <DigestionMotif> motifs = new List <DigestionMotif> {
new DigestionMotif("K", null, 1, null)
};
Protease protease = new Protease("Custom Protease5", CleavageSpecificity.Full, null, null, motifs);
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
CommonParameters CommonParameters = new CommonParameters(
digestionParams: new DigestionParams(
protease: protease.Name,
maxMissedCleavages: 0,
minPeptideLength: 1,
maxModificationIsoforms: 1042),
scoreCutoff: 1,
productMassTolerance: new PpmTolerance(10));
var fsp = new List <(string fileName, CommonParameters fileSpecificParameters)>();
fsp.Add(("", CommonParameters));
List <Modification> localizeableModifications = new List <Modification>();
List <Modification> variableModifications = new List <Modification>();
List <Modification> fixedModifications = new List <Modification>();
Dictionary <Modification, ushort> modsDictionary = new Dictionary <Modification, ushort>();
foreach (var mod in fixedModifications)
{
modsDictionary.Add(mod, 0);
}
int i = 1;
foreach (var mod in variableModifications)
{
modsDictionary.Add(mod, (ushort)i);
i++;
}
foreach (var mod in localizeableModifications)
{
modsDictionary.Add(mod, (ushort)i);
i++;
}
var proteinList = new List <Protein> {
new Protein("MNNNKQQQ", "accession")
};
var modPep = proteinList.First().Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).Last();
HashSet <PeptideWithSetModifications> value1 = new HashSet <PeptideWithSetModifications> {
modPep
};
PeptideWithSetModifications compactPeptide1 = value1.First();
Assert.AreEqual("QQQ", value1.First().BaseSequence);
var modPep2 = proteinList.First().Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).First();
HashSet <PeptideWithSetModifications> value2 = new HashSet <PeptideWithSetModifications> {
modPep2
};
PeptideWithSetModifications compactPeptide2 = value2.First();
Assert.AreEqual("MNNNK", value2.First().BaseSequence);
var modPep3 = proteinList.First().Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[1];
HashSet <PeptideWithSetModifications> value3 = new HashSet <PeptideWithSetModifications> {
modPep3
};
PeptideWithSetModifications compactPeptide3 = value3.First();
Assert.AreEqual("NNNK", value3.First().BaseSequence);
Ms2ScanWithSpecificMass scanA = new Ms2ScanWithSpecificMass(new MsDataScan(new MzSpectrum(new double[] { 1 }, new double[] { 1 }, false), 2, 1, true, Polarity.Positive, double.NaN, null, null, MZAnalyzerType.Orbitrap, double.NaN, null, null, "scan=1", double.NaN, null, null, double.NaN, null, DissociationType.AnyActivationType, 1, null), 1, 1, null, new CommonParameters());
Ms2ScanWithSpecificMass scanB = new Ms2ScanWithSpecificMass(new MsDataScan(new MzSpectrum(new double[] { 1 }, new double[] { 1 }, false), 3, 1, true, Polarity.Positive, double.NaN, null, null, MZAnalyzerType.Orbitrap, double.NaN, null, null, "scan=2", double.NaN, null, null, double.NaN, null, DissociationType.AnyActivationType, 1, null), 2 + 132.040, 1, null, new CommonParameters());
Ms2ScanWithSpecificMass scanC = new Ms2ScanWithSpecificMass(new MsDataScan(new MzSpectrum(new double[] { 1 }, new double[] { 1 }, false), 4, 1, true, Polarity.Positive, double.NaN, null, null, MZAnalyzerType.Orbitrap, double.NaN, null, null, "scan=3", double.NaN, null, null, double.NaN, null, DissociationType.AnyActivationType, 1, null), 3, 1, null, new CommonParameters());
PeptideSpectralMatch matchA = new PeptideSpectralMatch(compactPeptide1, 0, 0, 0, scanA, CommonParameters, new List <MatchedFragmentIon>());
PeptideSpectralMatch matchB = new PeptideSpectralMatch(compactPeptide2, 0, 0, 0, scanB, CommonParameters, new List <MatchedFragmentIon>());
PeptideSpectralMatch matchC = new PeptideSpectralMatch(compactPeptide3, 0, 0, 0, scanC, CommonParameters, new List <MatchedFragmentIon>());
var newPsms = new List <PeptideSpectralMatch> {
matchA, matchB, matchC
};
MsDataFile myMsDataFile = new TestDataFile(new List <PeptideWithSetModifications> {
value1.First(), value2.First(), value3.First()
});
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Action <List <PeptideSpectralMatch>, string, List <string> > action2 = (List <PeptideSpectralMatch> l, string s, List <string> sdf) => {; };
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var arrayOfMs2ScansSortedByMass = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
Action <BinTreeStructure, string> action1 = (BinTreeStructure l, string s) =>
{
Assert.AreEqual(1, l.FinalBins.Count);
};
FdrAnalysisEngine engine = new FdrAnalysisEngine(newPsms, searchMode.NumNotches, CommonParameters, fsp, new List <string> {
"ff"
});
engine.Run();
}
public static void TestAnalysisEngineTests()
{
CommonParameters CommonParameters = new CommonParameters
{
DigestionParams = new DigestionParams
{
Protease = new Protease("Custom Protease", new List <string> {
"K"
}, new List <string>(), TerminusType.C, CleavageSpecificity.Full, null, null, null),
MinPeptideLength = null,
MaxMissedCleavages = 0,
MaxModificationIsoforms = 1042,
},
ConserveMemory = false,
ScoreCutoff = 1,
ProductMassTolerance = new PpmTolerance(10),
};
List <ModificationWithMass> localizeableModifications = new List <ModificationWithMass>();
List <ModificationWithMass> variableModifications = new List <ModificationWithMass>();
List <ModificationWithMass> fixedModifications = new List <ModificationWithMass>();
Dictionary <ModificationWithMass, ushort> modsDictionary = new Dictionary <ModificationWithMass, ushort>();
foreach (var mod in fixedModifications)
{
modsDictionary.Add(mod, 0);
}
int i = 1;
foreach (var mod in variableModifications)
{
modsDictionary.Add(mod, (ushort)i);
i++;
}
foreach (var mod in localizeableModifications)
{
modsDictionary.Add(mod, (ushort)i);
i++;
}
var proteinList = new List <Protein> {
new Protein("MNNNKQQQ", "accession")
};
var modPep = proteinList.First().Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).Last();
HashSet <PeptideWithSetModifications> value1 = new HashSet <PeptideWithSetModifications> {
modPep
};
CompactPeptide compactPeptide1 = new CompactPeptide(value1.First(), TerminusType.None);
Assert.AreEqual("QQQ", value1.First().BaseSequence);
var modPep2 = proteinList.First().Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).First();
HashSet <PeptideWithSetModifications> value2 = new HashSet <PeptideWithSetModifications> {
modPep2
};
CompactPeptide compactPeptide2 = new CompactPeptide(value2.First(), TerminusType.None);
Assert.AreEqual("MNNNK", value2.First().BaseSequence);
var modPep3 = proteinList.First().Digest(CommonParameters.DigestionParams, fixedModifications, variableModifications).ToList()[1];
HashSet <PeptideWithSetModifications> value3 = new HashSet <PeptideWithSetModifications> {
modPep3
};
CompactPeptide compactPeptide3 = new CompactPeptide(value3.First(), TerminusType.None);
Assert.AreEqual("NNNK", value3.First().BaseSequence);
//newPsms[0] = new List<PsmParent>[] { new List<PsmParent>{ new PsmModern(compactPeptide1, null, 1, 1, 2, 2, 1,1, 1, 1, 3,0) },
// new List<PsmParent>{ new PsmModern(compactPeptide2, null, 2,2+132.040,3,3,2,2,2,2,2,0) },
// new List<PsmParent>{ new PsmModern(compactPeptide3, null, 3, 3, 4, 3, 3, 3, 3, 3, 3, 0)} };
Ms2ScanWithSpecificMass scanA = new Ms2ScanWithSpecificMass(new MzmlScanWithPrecursor(2, new MzmlMzSpectrum(new double[] { 1 }, new double[] { 1 }, false), 1, true, Polarity.Positive, double.NaN, null, null, MZAnalyzerType.Orbitrap, double.NaN, double.NaN, null, null, double.NaN, null, DissociationType.AnyActivationType, 1, null, null, "scan=1"), 1, 1, null);
Ms2ScanWithSpecificMass scanB = new Ms2ScanWithSpecificMass(new MzmlScanWithPrecursor(3, new MzmlMzSpectrum(new double[] { 1 }, new double[] { 1 }, false), 1, true, Polarity.Positive, double.NaN, null, null, MZAnalyzerType.Orbitrap, double.NaN, double.NaN, null, null, double.NaN, null, DissociationType.AnyActivationType, 1, null, null, "scan=2"), 2 + 132.040, 1, null);
Ms2ScanWithSpecificMass scanC = new Ms2ScanWithSpecificMass(new MzmlScanWithPrecursor(4, new MzmlMzSpectrum(new double[] { 1 }, new double[] { 1 }, false), 1, true, Polarity.Positive, double.NaN, null, null, MZAnalyzerType.Orbitrap, double.NaN, double.NaN, null, null, double.NaN, null, DissociationType.AnyActivationType, 1, null, null, "scan=3"), 3, 1, null);
PeptideSpectralMatch matchA = new PeptideSpectralMatch(compactPeptide1, 0, 0, 0, scanA);
PeptideSpectralMatch matchB = new PeptideSpectralMatch(compactPeptide2, 0, 0, 0, scanB);
PeptideSpectralMatch matchC = new PeptideSpectralMatch(compactPeptide3, 0, 0, 0, scanC);
var newPsms = new List <PeptideSpectralMatch> {
matchA, matchB, matchC
};
IMsDataFile <IMsDataScan <IMzSpectrum <IMzPeak> > > myMsDataFile = new TestDataFile(new List <PeptideWithSetModifications> {
value1.First(), value2.First(), value3.First()
});
var searchMode = new SinglePpmAroundZeroSearchMode(5);
Action <List <PeptideSpectralMatch>, string, List <string> > action2 = (List <PeptideSpectralMatch> l, string s, List <string> sdf) => {; };
bool DoPrecursorDeconvolution = true;
bool UseProvidedPrecursorInfo = true;
double DeconvolutionIntensityRatio = 4;
int DeconvolutionMaxAssumedChargeState = 10;
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var arrayOfMs2ScansSortedByMass = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, DoPrecursorDeconvolution, UseProvidedPrecursorInfo, DeconvolutionIntensityRatio, DeconvolutionMaxAssumedChargeState, DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
Action <BinTreeStructure, string> action1 = (BinTreeStructure l, string s) =>
{
Assert.AreEqual(1, l.FinalBins.Count);
};
SequencesToActualProteinPeptidesEngine sequencesToActualProteinPeptidesEngine = new SequencesToActualProteinPeptidesEngine(newPsms, proteinList, fixedModifications, variableModifications, new List <ProductType> {
ProductType.B, ProductType.Y
}, new List <IDigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters.ReportAllAmbiguity, new List <string>());
var res = (SequencesToActualProteinPeptidesEngineResults)sequencesToActualProteinPeptidesEngine.Run();
var compactPeptideToProteinPeptideMatching = res.CompactPeptideToProteinPeptideMatching;
foreach (var huh in newPsms)
{
if (huh != null)
{
huh.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching);
}
}
FdrAnalysisEngine engine = new FdrAnalysisEngine(newPsms, searchMode.NumNotches, false, new List <string> {
"ff"
});
engine.Run();
}
