public TwoPassCrosslinkSearchEngine(List <PsmCross> globalPsmsCross, Ms2ScanWithSpecificMass[] listOfSortedms2Scans, List <CompactPeptide> peptideIndex, List <int>[] fragmentIndex, List <ProductType> lp, int currentPartition, CommonParameters commonParameters, bool addCompIons, Tolerance XLPrecusorMsTl, CrosslinkerTypeClass crosslinker, bool CrosslinkSearchTop, int CrosslinkSearchTopNum, bool quench_H2O, bool quench_NH2, bool quench_Tris, bool charge_2_3, bool charge_2_3_PrimeFragment, List <string> nestedIds) : base(commonParameters, nestedIds)
{
this.GlobalPsmsCross = globalPsmsCross;
this.ListOfSortedms2Scans = listOfSortedms2Scans;
this.PeptideIndex = peptideIndex;
this.FragmentIndex = fragmentIndex;
this.ProductTypes = lp;
this.CurrentPartition = currentPartition + 1;
this.AddComplementaryIons = addCompIons;
//Here use LowTheoreticalDiffAcceptor in practice doesn't work in 12/2/2017
this.MassDiffAcceptor = new OpenSearchMode();
this.DissociationTypes = DetermineDissociationType(lp);
this.XLPrecusorMsTl = XLPrecusorMsTl;
XLPrecusorSearchMode = new SinglePpmAroundZeroSearchMode(XLPrecusorMsTl.Value);
//if (XLBetaPrecusorMsTl.ToString().Contains("Absolute"))
//{
// XLPrecusorSearchMode = new SingleAbsoluteAroundZeroSearchMode(XLPrecusorMsTl.Value);
//}
this.Crosslinker = crosslinker;
this.CrosslinkSearchTop = CrosslinkSearchTop;
this.CrosslinkSearchTopNum = CrosslinkSearchTopNum;
this.QuenchH2O = quench_H2O;
this.QuenchNH2 = quench_NH2;
this.QuenchTris = quench_Tris;
this.Charge_2_3 = charge_2_3;
this.Charge_2_3_PrimeFragment = charge_2_3_PrimeFragment;
}
public static void AddCompIonsCommonParams()
{
CommonParameters cp = new CommonParameters(null, DissociationType.HCD, DissociationType.Unknown, true, true, 3, 12, true, true, 1,
5, 200, 0.01, null, null, false, false, true, false, null, null, null, -1, null, null, null, 1, true, 4, 1);
var myMsDataFile = new TestDataFile();
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var localizeableModifications = new List <Modification>();
Dictionary <Modification, ushort> modsDictionary = new Dictionary <Modification, ushort>();
foreach (var mod in fixedModifications)
{
modsDictionary.Add(mod, 0);
}
int ii = 1;
foreach (var mod in variableModifications)
{
modsDictionary.Add(mod, (ushort)ii);
ii++;
}
foreach (var mod in localizeableModifications)
{
modsDictionary.Add(mod, (ushort)ii);
ii++;
}
var proteinList = new List <Protein> {
new Protein("MNNNKQQQ", null)
};
SearchParameters SearchParameters = new SearchParameters
{
MassDiffAcceptorType = MassDiffAcceptorType.Exact,
SearchTarget = true,
};
List <DigestionMotif> motifs = new List <DigestionMotif> {
new DigestionMotif("K", null, 1, null)
};
Protease protease = new Protease("Test", CleavageSpecificity.Full, null, null, motifs);
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
var indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, new List <SilacLabel>(),
1, DecoyType.Reverse, cp, SearchParameters.MaxFragmentSize, false, new List <FileInfo>(), new List <string>());
var indexResults = (IndexingResults)indexEngine.Run();
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
MassDiffAcceptor massDiffAcceptor = SearchTask.GetMassDiffAcceptor(cp.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
// without complementary ions
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
var mse = new ModernSearchEngine(allPsmsArray, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, 0, cp, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, new List <string>()).Run();
}
public CrosslinkSearchEngine(List <CrosslinkSpectralMatch>[] globalCsms, Ms2ScanWithSpecificMass[] listOfSortedms2Scans, List <PeptideWithSetModifications> peptideIndex,
List <int>[] fragmentIndex, List <int>[] secondFragmentIndex, int currentPartition, CommonParameters commonParameters, Crosslinker crosslinker, bool CrosslinkSearchTop, int CrosslinkSearchTopNum,
bool quench_H2O, bool quench_NH2, bool quench_Tris, List <string> nestedIds)
: base(null, listOfSortedms2Scans, peptideIndex, fragmentIndex, currentPartition, commonParameters, new OpenSearchMode(), 0, nestedIds)
{
this.GlobalCsms = globalCsms;
this.Crosslinker = crosslinker;
this.CrosslinkSearchTopN = CrosslinkSearchTop;
this.TopN = CrosslinkSearchTopNum;
this.QuenchH2O = quench_H2O;
this.QuenchNH2 = quench_NH2;
this.QuenchTris = quench_Tris;
SecondFragmentIndex = secondFragmentIndex;
if (CommonParameters.ChildScanDissociationType != DissociationType.Unknown && DissociationTypeGenerateSameTypeOfIons(CommonParameters.DissociationType, CommonParameters.ChildScanDissociationType))
{
SecondFragmentIndex = FragmentIndex;
}
GenerateCrosslinkModifications(crosslinker);
AllCrosslinkerSites = Crosslinker.CrosslinkerModSites.ToCharArray().Concat(Crosslinker.CrosslinkerModSites2.ToCharArray()).Distinct().ToArray();
if (commonParameters.PrecursorMassTolerance is PpmTolerance)
{
XLPrecusorSearchMode = new SinglePpmAroundZeroSearchMode(commonParameters.PrecursorMassTolerance.Value);
}
else
{
XLPrecusorSearchMode = new SingleAbsoluteAroundZeroSearchMode(commonParameters.PrecursorMassTolerance.Value);
}
}
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 ModernSearchEngine(PeptideSpectralMatch[] globalPsms, Ms2ScanWithSpecificMass[] listOfSortedms2Scans, List <PeptideWithSetModifications> peptideIndex, List <int>[] fragmentIndex, int currentPartition, CommonParameters commonParameters, MassDiffAcceptor massDiffAcceptor, double maximumMassThatFragmentIonScoreIsDoubled, List <string> nestedIds) : base(commonParameters, nestedIds)
{
PeptideSpectralMatches = globalPsms;
ListOfSortedMs2Scans = listOfSortedms2Scans;
PeptideIndex = peptideIndex;
FragmentIndex = fragmentIndex;
CurrentPartition = currentPartition + 1;
MassDiffAcceptor = massDiffAcceptor;
DissociationType = commonParameters.DissociationType;
MaxMassThatFragmentIonScoreIsDoubled = maximumMassThatFragmentIonScoreIsDoubled;
}
public ClassicSearchEngine(PeptideSpectralMatch[] globalPsms, Ms2ScanWithSpecificMass[] arrayOfSortedMS2Scans, List <ModificationWithMass> variableModifications, List <ModificationWithMass> fixedModifications, List <Protein> proteinList, List <ProductType> lp, MassDiffAcceptor searchMode, CommonParameters commonParameters, List <string> nestedIds) : base(commonParameters, nestedIds)
{
PeptideSpectralMatches = globalPsms;
ArrayOfSortedMS2Scans = arrayOfSortedMS2Scans;
MyScanPrecursorMasses = arrayOfSortedMS2Scans.Select(b => b.PrecursorMass).ToArray();
VariableModifications = variableModifications;
FixedModifications = fixedModifications;
Proteins = proteinList;
SearchMode = searchMode;
ProductTypes = lp;
DissociationTypes = DetermineDissociationType(lp);
}
private DataPointAquisitionResults GetDataAcquisitionResults(MsDataFile myMsDataFile, string currentDataFile, List <Modification> variableModifications, List <Modification> fixedModifications, List <Protein> proteinList, string taskId, CommonParameters combinedParameters, Tolerance initPrecTol, Tolerance initProdTol)
{
var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(currentDataFile);
MassDiffAcceptor searchMode = initPrecTol is PpmTolerance ?
(MassDiffAcceptor) new SinglePpmAroundZeroSearchMode(initPrecTol.Value) :
new SingleAbsoluteAroundZeroSearchMode(initPrecTol.Value);
var listOfSortedms2Scans = GetMs2Scans(myMsDataFile, currentDataFile, combinedParameters).OrderBy(b => b.PrecursorMass).ToArray();
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
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, null, null, null, proteinList, searchMode, combinedParameters, this.FileSpecificParameters, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
List <PeptideSpectralMatch> allPsms = allPsmsArray.Where(b => b != null).ToList();
allPsms = allPsms.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, CommonParameters, this.FileSpecificParameters, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
List <PeptideSpectralMatch> goodIdentifications = allPsms.Where(b => b.FdrInfo.QValueNotch < 0.001 && !b.IsDecoy && b.FullSequence != null).ToList();
if (!goodIdentifications.Any())
{
return(new DataPointAquisitionResults(null, new List <PeptideSpectralMatch>(), new List <LabeledDataPoint>(), new List <LabeledDataPoint>(), 0, 0, 0, 0));
}
DataPointAquisitionResults currentResult = (DataPointAquisitionResults) new DataPointAcquisitionEngine(
goodIdentifications,
myMsDataFile,
initPrecTol,
CalibrationParameters.MinMS1IsotopicPeaksNeededForConfirmedIdentification,
CommonParameters,
this.FileSpecificParameters,
new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
return(currentResult);
}
public ModernSearchEngine(PeptideSpectralMatch[] globalPsms, Ms2ScanWithSpecificMass[] listOfSortedms2Scans, List <CompactPeptide> peptideIndex, List <int>[] fragmentIndex, List <ProductType> lp, int currentPartition, ICommonParameters CommonParameters, bool addCompIons, MassDiffAcceptor massDiffAcceptor, double maximumMassThatFragmentIonScoreIsDoubled, List <string> nestedIds) : base(nestedIds)
{
this.globalPsms = globalPsms;
this.listOfSortedms2Scans = listOfSortedms2Scans;
this.peptideIndex = peptideIndex;
this.fragmentIndex = fragmentIndex;
this.lp = lp;
this.currentPartition = currentPartition + 1;
this.CommonParameters = CommonParameters;
this.addCompIons = addCompIons;
this.massDiffAcceptor = massDiffAcceptor;
this.dissociationTypes = DetermineDissociationType(lp);
this.maximumMassThatFragmentIonScoreIsDoubled = maximumMassThatFragmentIonScoreIsDoubled;
}
public ClassicSearchEngine(PeptideSpectralMatch[] globalPsms, Ms2ScanWithSpecificMass[] arrayOfSortedMS2Scans,
List <Modification> variableModifications, List <Modification> fixedModifications, List <SilacLabel> silacLabels,
List <Protein> proteinList, MassDiffAcceptor searchMode, CommonParameters commonParameters, List <string> nestedIds)
: base(commonParameters, nestedIds)
{
PeptideSpectralMatches = globalPsms;
ArrayOfSortedMS2Scans = arrayOfSortedMS2Scans;
MyScanPrecursorMasses = arrayOfSortedMS2Scans.Select(b => b.PrecursorMass).ToArray();
VariableModifications = variableModifications;
FixedModifications = fixedModifications;
SilacLabels = silacLabels;
Proteins = proteinList;
SearchMode = searchMode;
}
public ClassicSearchEngine(PeptideSpectralMatch[] globalPsms, Ms2ScanWithSpecificMass[] arrayOfSortedMS2Scans, List <ModificationWithMass> variableModifications, List <ModificationWithMass> fixedModifications, List <Protein> proteinList, List <ProductType> lp, MassDiffAcceptor searchMode, bool addCompIons, ICommonParameters CommonParameters, Tolerance productMassTolerance, List <string> nestedIds) : base(nestedIds)
{
this.peptideSpectralMatches = globalPsms;
this.arrayOfSortedMS2Scans = arrayOfSortedMS2Scans;
this.myScanPrecursorMasses = arrayOfSortedMS2Scans.Select(b => b.PrecursorMass).ToArray();
this.variableModifications = variableModifications;
this.fixedModifications = fixedModifications;
this.proteins = proteinList;
this.searchMode = searchMode;
this.lp = lp;
this.addCompIons = addCompIons;
this.dissociationTypes = DetermineDissociationType(lp);
this.commonParameters = CommonParameters;
this.productMassTolerance = productMassTolerance;
}
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 double[] ScanOxoniumIonFilter(Ms2ScanWithSpecificMass theScan, MassDiffAcceptor massDiffAcceptor, DissociationType dissociationType)
{
double[] oxoniumIonsintensities = new double[Glycan.AllOxoniumIons.Length];
if (dissociationType != DissociationType.HCD && dissociationType != DissociationType.CID && dissociationType != DissociationType.EThcD)
{
return(oxoniumIonsintensities);
}
for (int i = 0; i < Glycan.AllOxoniumIons.Length; i++)
{
var oxoMass = ((double)Glycan.AllOxoniumIons[i] / 1E5).ToMass(1);
var envelope = theScan.GetClosestExperimentalIsotopicEnvelope(oxoMass);
if (massDiffAcceptor.Accepts(envelope.MonoisotopicMass, oxoMass) >= 0)
{
oxoniumIonsintensities[i] = envelope.TotalIntensity;
}
}
return(oxoniumIonsintensities);
}
private IEnumerable <ScanWithIndexAndNotchInfo> GetAcceptableScans(double peptideMonoisotopicMass, MassDiffAcceptor searchMode)
{
foreach (AllowedIntervalWithNotch allowedIntervalWithNotch in searchMode.GetAllowedPrecursorMassIntervals(peptideMonoisotopicMass).ToList())
{
DoubleRange allowedInterval = allowedIntervalWithNotch.AllowedInterval;
int ScanIndex = GetFirstScanWithMassOverOrEqual(allowedInterval.Minimum);
if (ScanIndex < ArrayOfSortedMS2Scans.Length)
{
var scanMass = MyScanPrecursorMasses[ScanIndex];
while (scanMass <= allowedInterval.Maximum)
{
var TheScan = ArrayOfSortedMS2Scans[ScanIndex];
yield return(new ScanWithIndexAndNotchInfo(TheScan, allowedIntervalWithNotch.Notch, ScanIndex));
ScanIndex++;
if (ScanIndex == ArrayOfSortedMS2Scans.Length)
{
break;
}
scanMass = MyScanPrecursorMasses[ScanIndex];
}
}
}
}
protected void IndexedScoring(List <int> binsToSearch, byte[] scoringTable, byte byteScoreCutoff, List <int> idsOfPeptidesPossiblyObserved, double scanPrecursorMass, double lowestMassPeptideToLookFor,
double highestMassPeptideToLookFor, List <PeptideWithSetModifications> peptideIndex, MassDiffAcceptor massDiffAcceptor, double maxMassThatFragmentIonScoreIsDoubled, DissociationType dissociationType)
{
// get all theoretical fragments this experimental fragment could be
for (int i = 0; i < binsToSearch.Count; i++)
{
List <int> peptideIdsInThisBin = FragmentIndex[binsToSearch[i]];
//get index for minimum monoisotopic allowed
int lowestPeptideMassIndex = Double.IsInfinity(lowestMassPeptideToLookFor) ? 0 : BinarySearchBinForPrecursorIndex(peptideIdsInThisBin, lowestMassPeptideToLookFor, peptideIndex);
// get index for highest mass allowed
int highestPeptideMassIndex = peptideIdsInThisBin.Count - 1;
if (!Double.IsInfinity(highestMassPeptideToLookFor))
{
highestPeptideMassIndex = BinarySearchBinForPrecursorIndex(peptideIdsInThisBin, highestMassPeptideToLookFor, peptideIndex);
for (int j = highestPeptideMassIndex; j < peptideIdsInThisBin.Count; j++)
{
int nextId = peptideIdsInThisBin[j];
var nextPep = peptideIndex[nextId];
if (nextPep.MonoisotopicMass < highestMassPeptideToLookFor)
{
highestPeptideMassIndex = j;
}
else
{
break;
}
}
}
if (dissociationType == DissociationType.LowCID)
{
// add intensity for each peptide candidate in the scoring table up to the maximum allowed precursor mass
for (int j = lowestPeptideMassIndex; j <= highestPeptideMassIndex; j++)
{
int id = peptideIdsInThisBin[j];
// add possible search results to the hashset of id's (only once)
if (scoringTable[id] == 0 && massDiffAcceptor.Accepts(scanPrecursorMass, peptideIndex[id].MonoisotopicMass) >= 0)
{
idsOfPeptidesPossiblyObserved.Add(id);
}
// mark the peptide as potentially observed so it doesn't get added more than once
scoringTable[id] = 1;
}
}
else
{
// add +1 score for each peptide candidate in the scoring table up to the maximum allowed precursor mass
for (int j = lowestPeptideMassIndex; j <= highestPeptideMassIndex; j++)
{
int id = peptideIdsInThisBin[j];
scoringTable[id]++;
// add possible search results to the hashset of id's
if (scoringTable[id] == byteScoreCutoff && massDiffAcceptor.Accepts(scanPrecursorMass, peptideIndex[id].MonoisotopicMass) >= 0)
{
idsOfPeptidesPossiblyObserved.Add(id);
}
}
}
}
}
protected override MyTaskResults RunSpecific(string OutputFolder, List <DbForTask> dbFilenameList, List <string> currentRawFileList, string taskId, FileSpecificParameters[] fileSettingsList)
{
if (SearchParameters.DoQuantification)
{
// disable quantification if a .mgf is being used
if (currentRawFileList.Any(x => Path.GetExtension(x).Equals(".mgf", StringComparison.OrdinalIgnoreCase)))
{
SearchParameters.DoQuantification = false;
}
//if we're doing SILAC, assign and add the silac labels to the residue dictionary
else if (SearchParameters.SilacLabels != null || SearchParameters.StartTurnoverLabel != null || SearchParameters.EndTurnoverLabel != null)
{
char heavyLabel = 'a'; //char to assign
//add the Turnoverlabels to the silacLabels list. They weren't there before just to prevent duplication in the tomls
if (SearchParameters.StartTurnoverLabel != null || SearchParameters.EndTurnoverLabel != null)
{
//original silacLabels object is null, so we need to initialize it
SearchParameters.SilacLabels = new List <SilacLabel>();
if (SearchParameters.StartTurnoverLabel != null)
{
var updatedLabel = SilacConversions.UpdateAminoAcidLabel(SearchParameters.StartTurnoverLabel, heavyLabel);
heavyLabel = updatedLabel.nextHeavyLabel;
SearchParameters.StartTurnoverLabel = updatedLabel.updatedLabel;
SearchParameters.SilacLabels.Add(SearchParameters.StartTurnoverLabel);
}
if (SearchParameters.EndTurnoverLabel != null)
{
var updatedLabel = SilacConversions.UpdateAminoAcidLabel(SearchParameters.EndTurnoverLabel, heavyLabel);
heavyLabel = updatedLabel.nextHeavyLabel;
SearchParameters.EndTurnoverLabel = updatedLabel.updatedLabel;
SearchParameters.SilacLabels.Add(SearchParameters.EndTurnoverLabel);
}
}
else
{
//change the silac residues to lower case amino acids (currently null)
List <SilacLabel> updatedLabels = new List <SilacLabel>();
for (int i = 0; i < SearchParameters.SilacLabels.Count; i++)
{
var updatedLabel = SilacConversions.UpdateAminoAcidLabel(SearchParameters.SilacLabels[i], heavyLabel);
heavyLabel = updatedLabel.nextHeavyLabel;
updatedLabels.Add(updatedLabel.updatedLabel);
}
SearchParameters.SilacLabels = updatedLabels;
}
}
}
//if no quant, remove any silac labels that may have been added, because they screw up downstream analysis
if (!SearchParameters.DoQuantification) //using "if" instead of "else", because DoQuantification can change if it's an mgf
{
SearchParameters.SilacLabels = null;
}
LoadModifications(taskId, out var variableModifications, out var fixedModifications, out var localizeableModificationTypes);
// load proteins
List <Protein> proteinList = LoadProteins(taskId, dbFilenameList, SearchParameters.SearchTarget, SearchParameters.DecoyType, localizeableModificationTypes, CommonParameters);
SanitizeProteinDatabase(proteinList, SearchParameters.TCAmbiguity);
// load spectral libraries
var spectralLibrary = LoadSpectralLibraries(taskId, dbFilenameList);
// write prose settings
ProseCreatedWhileRunning.Append("The following search settings were used: ");
ProseCreatedWhileRunning.Append("protease = " + CommonParameters.DigestionParams.Protease + "; ");
ProseCreatedWhileRunning.Append("maximum missed cleavages = " + CommonParameters.DigestionParams.MaxMissedCleavages + "; ");
ProseCreatedWhileRunning.Append("minimum peptide length = " + CommonParameters.DigestionParams.MinPeptideLength + "; ");
ProseCreatedWhileRunning.Append(CommonParameters.DigestionParams.MaxPeptideLength == int.MaxValue ?
"maximum peptide length = unspecified; " :
"maximum peptide length = " + CommonParameters.DigestionParams.MaxPeptideLength + "; ");
ProseCreatedWhileRunning.Append("initiator methionine behavior = " + CommonParameters.DigestionParams.InitiatorMethionineBehavior + "; ");
ProseCreatedWhileRunning.Append("fixed modifications = " + string.Join(", ", fixedModifications.Select(m => m.IdWithMotif)) + "; ");
ProseCreatedWhileRunning.Append("variable modifications = " + string.Join(", ", variableModifications.Select(m => m.IdWithMotif)) + "; ");
ProseCreatedWhileRunning.Append("max mods per peptide = " + CommonParameters.DigestionParams.MaxModsForPeptide + "; ");
ProseCreatedWhileRunning.Append("max modification isoforms = " + CommonParameters.DigestionParams.MaxModificationIsoforms + "; ");
ProseCreatedWhileRunning.Append("precursor mass tolerance = " + CommonParameters.PrecursorMassTolerance + "; ");
ProseCreatedWhileRunning.Append("product mass tolerance = " + CommonParameters.ProductMassTolerance + "; ");
ProseCreatedWhileRunning.Append("report PSM ambiguity = " + CommonParameters.ReportAllAmbiguity + ". ");
ProseCreatedWhileRunning.Append("The combined search database contained " + proteinList.Count(p => !p.IsDecoy)
+ " non-decoy protein entries including " + proteinList.Count(p => p.IsContaminant) + " contaminant sequences. ");
// start the search task
MyTaskResults = new MyTaskResults(this);
List <PeptideSpectralMatch> allPsms = new List <PeptideSpectralMatch>();
//generate an array to store category specific fdr values (for speedy semi/nonspecific searches)
int numFdrCategories = (int)(Enum.GetValues(typeof(FdrCategory)).Cast <FdrCategory>().Last() + 1); //+1 because it starts at zero
List <PeptideSpectralMatch>[] allCategorySpecificPsms = new List <PeptideSpectralMatch> [numFdrCategories];
for (int i = 0; i < numFdrCategories; i++)
{
allCategorySpecificPsms[i] = new List <PeptideSpectralMatch>();
}
FlashLfqResults flashLfqResults = null;
MyFileManager myFileManager = new MyFileManager(SearchParameters.DisposeOfFileWhenDone);
var fileSpecificCommonParams = fileSettingsList.Select(b => SetAllFileSpecificCommonParams(CommonParameters, b));
int completedFiles = 0;
object indexLock = new object();
object psmLock = new object();
Status("Searching files...", taskId);
Status("Searching files...", new List <string> {
taskId, "Individual Spectra Files"
});
Dictionary <string, int[]> numMs2SpectraPerFile = new Dictionary <string, int[]>();
for (int spectraFileIndex = 0; spectraFileIndex < currentRawFileList.Count; spectraFileIndex++)
{
if (GlobalVariables.StopLoops)
{
break;
}
var origDataFile = currentRawFileList[spectraFileIndex];
// mark the file as in-progress
StartingDataFile(origDataFile, new List <string> {
taskId, "Individual Spectra Files", origDataFile
});
CommonParameters combinedParams = SetAllFileSpecificCommonParams(CommonParameters, fileSettingsList[spectraFileIndex]);
MassDiffAcceptor massDiffAcceptor = GetMassDiffAcceptor(combinedParams.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
var thisId = new List <string> {
taskId, "Individual Spectra Files", origDataFile
};
NewCollection(Path.GetFileName(origDataFile), thisId);
Status("Loading spectra file...", thisId);
MsDataFile myMsDataFile = myFileManager.LoadFile(origDataFile, combinedParams);
Status("Getting ms2 scans...", thisId);
Ms2ScanWithSpecificMass[] arrayOfMs2ScansSortedByMass = GetMs2Scans(myMsDataFile, origDataFile, combinedParams).OrderBy(b => b.PrecursorMass).ToArray();
numMs2SpectraPerFile.Add(Path.GetFileNameWithoutExtension(origDataFile), new int[] { myMsDataFile.GetAllScansList().Count(p => p.MsnOrder == 2), arrayOfMs2ScansSortedByMass.Length });
myFileManager.DoneWithFile(origDataFile);
PeptideSpectralMatch[] fileSpecificPsms = new PeptideSpectralMatch[arrayOfMs2ScansSortedByMass.Length];
// modern search
if (SearchParameters.SearchType == SearchType.Modern)
{
for (int currentPartition = 0; currentPartition < combinedParams.TotalPartitions; currentPartition++)
{
List <PeptideWithSetModifications> peptideIndex = null;
List <Protein> proteinListSubset = proteinList.GetRange(currentPartition * proteinList.Count / combinedParams.TotalPartitions,
((currentPartition + 1) * proteinList.Count / combinedParams.TotalPartitions) - (currentPartition * proteinList.Count / combinedParams.TotalPartitions));
Status("Getting fragment dictionary...", new List <string> {
taskId
});
var indexEngine = new IndexingEngine(proteinListSubset, variableModifications, fixedModifications, SearchParameters.SilacLabels,
SearchParameters.StartTurnoverLabel, SearchParameters.EndTurnoverLabel, currentPartition, SearchParameters.DecoyType, combinedParams, FileSpecificParameters,
SearchParameters.MaxFragmentSize, false, dbFilenameList.Select(p => new FileInfo(p.FilePath)).ToList(), SearchParameters.TCAmbiguity, new List <string> {
taskId
});
List <int>[] fragmentIndex = null;
List <int>[] precursorIndex = null;
lock (indexLock)
{
GenerateIndexes(indexEngine, dbFilenameList, ref peptideIndex, ref fragmentIndex, ref precursorIndex, proteinList, taskId);
}
Status("Searching files...", taskId);
new ModernSearchEngine(fileSpecificPsms, arrayOfMs2ScansSortedByMass, peptideIndex, fragmentIndex, currentPartition,
combinedParams, this.FileSpecificParameters, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, thisId).Run();
ReportProgress(new ProgressEventArgs(100, "Done with search " + (currentPartition + 1) + "/" + combinedParams.TotalPartitions + "!", thisId));
if (GlobalVariables.StopLoops)
{
break;
}
}
}
// nonspecific search
else if (SearchParameters.SearchType == SearchType.NonSpecific)
{
PeptideSpectralMatch[][] fileSpecificPsmsSeparatedByFdrCategory = new PeptideSpectralMatch[numFdrCategories][]; //generate an array of all possible locals
for (int i = 0; i < numFdrCategories; i++) //only add if we're using for FDR, else ignore it as null.
{
fileSpecificPsmsSeparatedByFdrCategory[i] = new PeptideSpectralMatch[arrayOfMs2ScansSortedByMass.Length];
}
//create params for N, C, or both if semi
List <CommonParameters> paramsToUse = new List <CommonParameters> {
combinedParams
};
if (combinedParams.DigestionParams.SearchModeType == CleavageSpecificity.Semi) //if semi, we need to do both N and C to hit everything
{
paramsToUse.Clear();
List <FragmentationTerminus> terminiToUse = new List <FragmentationTerminus> {
FragmentationTerminus.N, FragmentationTerminus.C
};
foreach (FragmentationTerminus terminus in terminiToUse) //set both termini
{
paramsToUse.Add(combinedParams.CloneWithNewTerminus(terminus));
}
}
//Compress array of deconvoluted ms2 scans to avoid searching the same ms2 multiple times while still identifying coisolated peptides
List <int>[] coisolationIndex = new List <int>[] { new List <int>() };
if (arrayOfMs2ScansSortedByMass.Length != 0)
{
int maxScanNumber = arrayOfMs2ScansSortedByMass.Max(x => x.OneBasedScanNumber);
coisolationIndex = new List <int> [maxScanNumber + 1];
for (int i = 0; i < arrayOfMs2ScansSortedByMass.Length; i++)
{
int scanNumber = arrayOfMs2ScansSortedByMass[i].OneBasedScanNumber;
if (coisolationIndex[scanNumber] == null)
{
coisolationIndex[scanNumber] = new List <int> {
i
};
}
else
{
coisolationIndex[scanNumber].Add(i);
}
}
coisolationIndex = coisolationIndex.Where(x => x != null).ToArray();
}
//foreach terminus we're going to look at
foreach (CommonParameters paramToUse in paramsToUse)
{
//foreach database partition
for (int currentPartition = 0; currentPartition < paramToUse.TotalPartitions; currentPartition++)
{
List <PeptideWithSetModifications> peptideIndex = null;
List <Protein> proteinListSubset = proteinList.GetRange(currentPartition * proteinList.Count / paramToUse.TotalPartitions,
((currentPartition + 1) * proteinList.Count / paramToUse.TotalPartitions) - (currentPartition * proteinList.Count / paramToUse.TotalPartitions));
List <int>[] fragmentIndex = null;
List <int>[] precursorIndex = null;
Status("Getting fragment dictionary...", new List <string> {
taskId
});
var indexEngine = new IndexingEngine(proteinListSubset, variableModifications, fixedModifications, SearchParameters.SilacLabels,
SearchParameters.StartTurnoverLabel, SearchParameters.EndTurnoverLabel, currentPartition, SearchParameters.DecoyType, paramToUse, FileSpecificParameters,
SearchParameters.MaxFragmentSize, true, dbFilenameList.Select(p => new FileInfo(p.FilePath)).ToList(), SearchParameters.TCAmbiguity, new List <string> {
taskId
});
lock (indexLock)
{
GenerateIndexes(indexEngine, dbFilenameList, ref peptideIndex, ref fragmentIndex, ref precursorIndex, proteinList, taskId);
}
Status("Searching files...", taskId);
new NonSpecificEnzymeSearchEngine(fileSpecificPsmsSeparatedByFdrCategory, arrayOfMs2ScansSortedByMass, coisolationIndex, peptideIndex, fragmentIndex,
precursorIndex, currentPartition, paramToUse, this.FileSpecificParameters, variableModifications, massDiffAcceptor,
SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, thisId).Run();
ReportProgress(new ProgressEventArgs(100, "Done with search " + (currentPartition + 1) + "/" + paramToUse.TotalPartitions + "!", thisId));
if (GlobalVariables.StopLoops)
{
break;
}
}
}
lock (psmLock)
{
for (int i = 0; i < allCategorySpecificPsms.Length; i++)
{
if (allCategorySpecificPsms[i] != null)
{
allCategorySpecificPsms[i].AddRange(fileSpecificPsmsSeparatedByFdrCategory[i]);
}
}
}
}
// classic search
else
{
Status("Starting search...", thisId);
var newClassicSearchEngine = new ClassicSearchEngine(fileSpecificPsms, arrayOfMs2ScansSortedByMass, variableModifications, fixedModifications, SearchParameters.SilacLabels,
SearchParameters.StartTurnoverLabel, SearchParameters.EndTurnoverLabel, proteinList, massDiffAcceptor, combinedParams, this.FileSpecificParameters, spectralLibrary, thisId, SearchParameters.WriteSpectralLibrary);
newClassicSearchEngine.Run();
ReportProgress(new ProgressEventArgs(100, "Done with search!", thisId));
}
//look for internal fragments
if (SearchParameters.MinAllowedInternalFragmentLength != 0)
{
MatchInternalFragmentIons(fileSpecificPsms, arrayOfMs2ScansSortedByMass, combinedParams, SearchParameters.MinAllowedInternalFragmentLength);
}
// calculate/set spectral angles if there is a spectral library being used
if (spectralLibrary != null)
{
Status("Calculating spectral library similarity...", thisId);
}
SpectralLibrarySearchFunction.CalculateSpectralAngles(spectralLibrary, fileSpecificPsms, arrayOfMs2ScansSortedByMass, combinedParams);
lock (psmLock)
{
allPsms.AddRange(fileSpecificPsms);
}
completedFiles++;
FinishedDataFile(origDataFile, new List <string> {
taskId, "Individual Spectra Files", origDataFile
});
ReportProgress(new ProgressEventArgs(completedFiles / currentRawFileList.Count, "Searching...", new List <string> {
taskId, "Individual Spectra Files"
}));
}
if (spectralLibrary != null)
{
spectralLibrary.CloseConnections();
}
ReportProgress(new ProgressEventArgs(100, "Done with all searches!", new List <string> {
taskId, "Individual Spectra Files"
}));
int numNotches = GetNumNotches(SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
//resolve category specific fdrs (for speedy semi and nonspecific
if (SearchParameters.SearchType == SearchType.NonSpecific)
{
allPsms = NonSpecificEnzymeSearchEngine.ResolveFdrCategorySpecificPsms(allCategorySpecificPsms, numNotches, taskId, CommonParameters, FileSpecificParameters);
}
PostSearchAnalysisParameters parameters = new PostSearchAnalysisParameters
{
SearchTaskResults = MyTaskResults,
SearchTaskId = taskId,
SearchParameters = SearchParameters,
ProteinList = proteinList,
AllPsms = allPsms,
VariableModifications = variableModifications,
FixedModifications = fixedModifications,
ListOfDigestionParams = new HashSet <DigestionParams>(fileSpecificCommonParams.Select(p => p.DigestionParams)),
CurrentRawFileList = currentRawFileList,
MyFileManager = myFileManager,
NumNotches = numNotches,
OutputFolder = OutputFolder,
IndividualResultsOutputFolder = Path.Combine(OutputFolder, "Individual File Results"),
FlashLfqResults = flashLfqResults,
FileSettingsList = fileSettingsList,
NumMs2SpectraPerFile = numMs2SpectraPerFile,
DatabaseFilenameList = dbFilenameList
};
PostSearchAnalysisTask postProcessing = new PostSearchAnalysisTask
{
Parameters = parameters,
FileSpecificParameters = this.FileSpecificParameters,
CommonParameters = CommonParameters
};
return(postProcessing.Run());
}
private Tuple <int, PeptideWithSetModifications> Accepts(List <Product> fragments, double scanPrecursorMass, PeptideWithSetModifications peptide, FragmentationTerminus fragmentationTerminus, MassDiffAcceptor searchMode)
{
//all masses in N and CTerminalMasses are b-ion masses, which are one water away from a full peptide
int localminPeptideLength = commonParameters.DigestionParams.MinPeptideLength;
for (int i = localminPeptideLength - 1; i < fragments.Count; i++) //minus one start, because fragment 1 is at index 0
{
Product fragment = fragments[i];
double theoMass = fragment.NeutralMass - DissociationTypeCollection.GetMassShiftFromProductType(fragment.ProductType) + WaterMonoisotopicMass;
int notch = searchMode.Accepts(scanPrecursorMass, theoMass);
if (notch >= 0)
{
PeptideWithSetModifications updatedPwsm = null;
if (fragmentationTerminus == FragmentationTerminus.N)
{
int endResidue = peptide.OneBasedStartResidueInProtein + fragment.TerminusFragment.FragmentNumber - 1; //-1 for one based index
Dictionary <int, Modification> updatedMods = new Dictionary <int, Modification>();
foreach (KeyValuePair <int, Modification> mod in peptide.AllModsOneIsNterminus)
{
if (mod.Key < endResidue - peptide.OneBasedStartResidueInProtein + 3) //check if we cleaved it off, +1 for N-terminus being mod 1 and first residue being mod 2, +1 again for the -1 on end residue for one based index, +1 (again) for the one-based start residue
{
updatedMods.Add(mod.Key, mod.Value);
}
}
updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, peptide.OneBasedStartResidueInProtein, endResidue, CleavageSpecificity.Unknown, "", 0, updatedMods, 0);
}
else
{
int startResidue = peptide.OneBasedEndResidueInProtein - fragment.TerminusFragment.FragmentNumber + 1; //plus one for one based index
Dictionary <int, Modification> updatedMods = new Dictionary <int, Modification>(); //updateMods
int indexShift = startResidue - peptide.OneBasedStartResidueInProtein;
foreach (KeyValuePair <int, Modification> mod in peptide.AllModsOneIsNterminus)
{
if (mod.Key > indexShift + 1) //check if we cleaved it off, +1 for N-terminus being mod 1 and first residue being 2
{
int key = mod.Key - indexShift;
updatedMods.Add(key, mod.Value);
}
}
updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, startResidue, peptide.OneBasedEndResidueInProtein, CleavageSpecificity.Unknown, "", 0, updatedMods, 0);
}
return(new Tuple <int, PeptideWithSetModifications>(notch, updatedPwsm));
}
else if (theoMass > scanPrecursorMass)
{
break;
}
}
//if the theoretical and experimental have the same mass
if (fragments.Count > localminPeptideLength)
{
double totalMass = peptide.MonoisotopicMass;// + Constants.ProtonMass;
int notch = searchMode.Accepts(scanPrecursorMass, totalMass);
if (notch >= 0)
{
//need to update so that the cleavage specificity is recorded
PeptideWithSetModifications updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, peptide.OneBasedStartResidueInProtein, peptide.OneBasedEndResidueInProtein, CleavageSpecificity.Unknown, "", 0, peptide.AllModsOneIsNterminus, peptide.NumFixedMods);
return(new Tuple <int, PeptideWithSetModifications>(notch, updatedPwsm));
}
}
return(new Tuple <int, PeptideWithSetModifications>(-1, null));
}
public static void TestCompIons_ModernSearch()
{
var myMsDataFile = new TestDataFile();
var variableModifications = new List <Modification>();
var fixedModifications = new List <Modification>();
var localizeableModifications = new List <Modification>();
Dictionary <Modification, ushort> modsDictionary = new Dictionary <Modification, ushort>();
foreach (var mod in fixedModifications)
{
modsDictionary.Add(mod, 0);
}
int ii = 1;
foreach (var mod in variableModifications)
{
modsDictionary.Add(mod, (ushort)ii);
ii++;
}
foreach (var mod in localizeableModifications)
{
modsDictionary.Add(mod, (ushort)ii);
ii++;
}
var proteinList = new List <Protein> {
new Protein("MNNNKQQQ", null)
};
SearchParameters SearchParameters = new SearchParameters
{
MassDiffAcceptorType = MassDiffAcceptorType.Exact,
SearchTarget = true,
};
List <DigestionMotif> motifs = new List <DigestionMotif> {
new DigestionMotif("K", null, 1, null)
};
Protease protease = new Protease("singleN4", CleavageSpecificity.Full, null, null, motifs);
ProteaseDictionary.Dictionary.Add(protease.Name, protease);
CommonParameters CommonParameters = new CommonParameters(digestionParams: new DigestionParams(protease: protease.Name, minPeptideLength: 1), scoreCutoff: 1);
var fsp = new List <(string fileName, CommonParameters fileSpecificParameters)>();
fsp.Add(("", CommonParameters));
CommonParameters withCompIons = new CommonParameters(digestionParams: new DigestionParams(protease: protease.Name, minPeptideLength: 1), scoreCutoff: 1, addCompIons: true);
var fspComp = new List <(string fileName, CommonParameters fileSpecificParameters)>();
fspComp.Add(("", CommonParameters));
var indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, null, null, null,
1, DecoyType.Reverse, CommonParameters, fsp, SearchParameters.MaxFragmentSize, false, new List <FileInfo>(), TargetContaminantAmbiguity.RemoveContaminant, new List <string>());
var indexResults = (IndexingResults)indexEngine.Run();
Tolerance DeconvolutionMassTolerance = new PpmTolerance(5);
var listOfSortedms2Scans = MetaMorpheusTask.GetMs2Scans(myMsDataFile, null, new CommonParameters()).OrderBy(b => b.PrecursorMass).ToArray();
MassDiffAcceptor massDiffAcceptor = SearchTask.GetMassDiffAcceptor(CommonParameters.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
// without complementary ions
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArray, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, 0, CommonParameters, fsp, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, new List <string>()).Run();
// with complementary ions
PeptideSpectralMatch[] allPsmsArray2 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArray2, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, 0, withCompIons, fspComp, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, new List <string>()).Run();
// Single search mode
Assert.AreEqual(allPsmsArray.Length, allPsmsArray2.Length);
// Single ms2 scan
Assert.AreEqual(allPsmsArray.Length, allPsmsArray2.Length);
Assert.That(allPsmsArray[0] != null);
Assert.That(allPsmsArray2[0] != null);
Assert.IsTrue(allPsmsArray2[0].Score > 1);
Assert.AreEqual(allPsmsArray[0].ScanNumber, allPsmsArray2[0].ScanNumber);
Assert.IsTrue(allPsmsArray2[0].Score <= allPsmsArray[0].Score * 2 && allPsmsArray2[0].Score > allPsmsArray[0].Score + 3);
}
public NonSpecificEnzymeSequencesToActualPeptides(Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> > CPWMtoPWSM, List <PeptideSpectralMatch> allPsms, List <Protein> proteinList, List <ModificationWithMass> fixedModifications, List <ModificationWithMass> variableModifications, List <ProductType> ionTypes, IEnumerable <IDigestionParams> CollectionOfDigestionParams, MassDiffAcceptor massDiffAcceptor, bool reportAllAmbiguity, List <string> nestedIds) : base(allPsms, proteinList, fixedModifications, variableModifications, ionTypes, CollectionOfDigestionParams, reportAllAmbiguity, nestedIds)
{
this.massDiffAcceptor = massDiffAcceptor;
this.CPWMtoPWSM = CPWMtoPWSM;
}
public NonSpecificEnzymeSearchEngine(PeptideSpectralMatch[][] globalPsms, Ms2ScanWithSpecificMass[] listOfSortedms2Scans,
List <PeptideWithSetModifications> peptideIndex, List <int>[] fragmentIndex, List <int>[] precursorIndex, int currentPartition,
CommonParameters commonParameters, List <Modification> variableModifications, MassDiffAcceptor massDiffAcceptor, double maximumMassThatFragmentIonScoreIsDoubled, List <string> nestedIds)
: base(null, listOfSortedms2Scans, peptideIndex, fragmentIndex, currentPartition, commonParameters, massDiffAcceptor, maximumMassThatFragmentIonScoreIsDoubled, nestedIds)
{
PrecursorIndex = precursorIndex;
MinimumPeptideLength = commonParameters.DigestionParams.MinPeptideLength;
GlobalCategorySpecificPsms = globalPsms;
ModifiedParametersNoComp = commonParameters.CloneWithNewTerminus(addCompIons: false);
ProductTypesToSearch = DissociationTypeCollection.ProductsFromDissociationType[commonParameters.DissociationType].Intersect(TerminusSpecificProductTypes.ProductIonTypesFromSpecifiedTerminus[commonParameters.DigestionParams.FragmentationTerminus]).ToList();
VariableTerminalModifications = GetVariableTerminalMods(commonParameters.DigestionParams.FragmentationTerminus, variableModifications);
}
private void SaveButton_Click(object sender, RoutedEventArgs e)
{
CleavageSpecificity searchModeType = CleavageSpecificity.Full; //classic and modern by default
if (semiSpecificSearchRadioButton.IsChecked.Value) //semi
{
searchModeType = CleavageSpecificity.Semi;
}
else if (nonSpecificSearchRadioButton.IsChecked.Value) //non
{
searchModeType = CleavageSpecificity.None;
}
//else it's the default of full
if (searchModeType != CleavageSpecificity.Full)
{
if (((Protease)proteaseComboBox.SelectedItem).Name.Contains("non-specific"))
{
searchModeType = CleavageSpecificity.None; //prevents an accidental semi attempt of a non-specific protease
if (cTerminalIons.IsChecked.Value)
{
Protease singleC = ProteaseDictionary.Dictionary["singleC"];
proteaseComboBox.SelectedItem = singleC;
}
else //we're not allowing no ion types. It must have N if it doesn't have C.
{
Protease singleN = ProteaseDictionary.Dictionary["singleN"];
proteaseComboBox.SelectedItem = singleN;
}
}
if (!addCompIonCheckBox.IsChecked.Value)
{
MessageBox.Show("Warning: Complementary ions are strongly recommended when using this algorithm.");
}
//only use N or C termini, not both
if (cTerminalIons.IsChecked.Value)
{
nTerminalIons.IsChecked = false;
}
else
{
nTerminalIons.IsChecked = true;
}
}
if (!GlobalGuiSettings.CheckTaskSettingsValidity(precursorMassToleranceTextBox.Text, productMassToleranceTextBox.Text, missedCleavagesTextBox.Text,
maxModificationIsoformsTextBox.Text, MinPeptideLengthTextBox.Text, MaxPeptideLengthTextBox.Text, maxThreadsTextBox.Text, minScoreAllowed.Text,
peakFindingToleranceTextBox.Text, histogramBinWidthTextBox.Text, DeconvolutionMaxAssumedChargeStateTextBox.Text, NumberOfPeaksToKeepPerWindowTextBox.Text,
MinimumAllowedIntensityRatioToBasePeakTexBox.Text, WindowWidthThomsonsTextBox.Text, NumberOfWindowsTextBox.Text, numberOfDatabaseSearchesTextBox.Text, MaxModNumTextBox.Text, MaxFragmentMassTextBox.Text, QValueTextBox.Text))
{
return;
}
Protease protease = (Protease)proteaseComboBox.SelectedItem;
DissociationType dissociationType = GlobalVariables.AllSupportedDissociationTypes[dissociationTypeComboBox.SelectedItem.ToString()];
CustomFragmentationWindow.Close();
FragmentationTerminus fragmentationTerminus = FragmentationTerminus.Both;
if (nTerminalIons.IsChecked.Value && !cTerminalIons.IsChecked.Value)
{
fragmentationTerminus = FragmentationTerminus.N;
}
else if (!nTerminalIons.IsChecked.Value && cTerminalIons.IsChecked.Value)
{
fragmentationTerminus = FragmentationTerminus.C;
}
else if (!nTerminalIons.IsChecked.Value && !cTerminalIons.IsChecked.Value) //why would you want this
{
fragmentationTerminus = FragmentationTerminus.None;
MessageBox.Show("Warning: No ion types were selected. MetaMorpheus will be unable to search MS/MS spectra.");
}
//else both
int maxMissedCleavages = string.IsNullOrEmpty(missedCleavagesTextBox.Text) ? int.MaxValue : (int.Parse(missedCleavagesTextBox.Text, NumberStyles.Any, CultureInfo.InvariantCulture));
int minPeptideLengthValue = (int.Parse(MinPeptideLengthTextBox.Text, NumberStyles.Any, CultureInfo.InvariantCulture));
int maxPeptideLengthValue = string.IsNullOrEmpty(MaxPeptideLengthTextBox.Text) ? int.MaxValue : (int.Parse(MaxPeptideLengthTextBox.Text, NumberStyles.Any, CultureInfo.InvariantCulture));
int MinVariantDepth = int.Parse(MinVariantDepthTextBox.Text, NumberStyles.Any, CultureInfo.InvariantCulture);
int MaxHeterozygousVariants = int.Parse(MaxHeterozygousVariantsTextBox.Text, NumberStyles.Any, CultureInfo.InvariantCulture);
int maxModificationIsoformsValue = (int.Parse(maxModificationIsoformsTextBox.Text, CultureInfo.InvariantCulture));
int maxModsForPeptideValue = (int.Parse(MaxModNumTextBox.Text, CultureInfo.InvariantCulture));
InitiatorMethionineBehavior initiatorMethionineBehavior = ((InitiatorMethionineBehavior)initiatorMethionineBehaviorComboBox.SelectedIndex);
DigestionParams digestionParamsToSave = new DigestionParams(
protease: protease.Name,
maxMissedCleavages: maxMissedCleavages,
minPeptideLength: minPeptideLengthValue,
maxPeptideLength: maxPeptideLengthValue,
maxModificationIsoforms: maxModificationIsoformsValue,
initiatorMethionineBehavior: initiatorMethionineBehavior,
maxModsForPeptides: maxModsForPeptideValue,
searchModeType: searchModeType,
fragmentationTerminus: fragmentationTerminus,
generateUnlabeledProteinsForSilac: CheckBoxQuantifyUnlabeledForSilac.IsChecked.Value);
Tolerance ProductMassTolerance;
if (productMassToleranceComboBox.SelectedIndex == 0)
{
ProductMassTolerance = new AbsoluteTolerance(double.Parse(productMassToleranceTextBox.Text, CultureInfo.InvariantCulture));
}
else
{
ProductMassTolerance = new PpmTolerance(double.Parse(productMassToleranceTextBox.Text, CultureInfo.InvariantCulture));
}
Tolerance PrecursorMassTolerance;
if (precursorMassToleranceComboBox.SelectedIndex == 0)
{
PrecursorMassTolerance = new AbsoluteTolerance(double.Parse(precursorMassToleranceTextBox.Text, CultureInfo.InvariantCulture));
}
else
{
PrecursorMassTolerance = new PpmTolerance(double.Parse(precursorMassToleranceTextBox.Text, CultureInfo.InvariantCulture));
}
TheTask.SearchParameters.MaxFragmentSize = Double.Parse(MaxFragmentMassTextBox.Text, CultureInfo.InvariantCulture);
var listOfModsVariable = new List <(string, string)>();
foreach (var heh in VariableModTypeForTreeViewObservableCollection)
{
listOfModsVariable.AddRange(heh.Children.Where(b => b.Use).Select(b => (b.Parent.DisplayName, b.ModName)));
}
var listOfModsFixed = new List <(string, string)>();
foreach (var heh in FixedModTypeForTreeViewObservableCollection)
{
listOfModsFixed.AddRange(heh.Children.Where(b => b.Use).Select(b => (b.Parent.DisplayName, b.ModName)));
}
if (!GlobalGuiSettings.VariableModCheck(listOfModsVariable))
{
return;
}
bool TrimMs1Peaks = trimMs1.IsChecked.Value;
bool TrimMsMsPeaks = trimMsMs.IsChecked.Value;
int?numPeaksToKeep = null;
if (int.TryParse(NumberOfPeaksToKeepPerWindowTextBox.Text, out int numberOfPeaksToKeeep))
{
numPeaksToKeep = numberOfPeaksToKeeep;
}
double?minimumAllowedIntensityRatioToBasePeak = null;
if (double.TryParse(MinimumAllowedIntensityRatioToBasePeakTexBox.Text, out double minimumAllowedIntensityRatio))
{
minimumAllowedIntensityRatioToBasePeak = minimumAllowedIntensityRatio;
}
double?windowWidthThompsons = null;
if (double.TryParse(WindowWidthThomsonsTextBox.Text, out double windowWidth))
{
windowWidthThompsons = windowWidth;
}
int?numberOfWindows = null;
if (int.TryParse(NumberOfWindowsTextBox.Text, out int numWindows))
{
numberOfWindows = numWindows;
}
bool normalizePeaksAccrossAllWindows = normalizePeaksInWindowCheckBox.IsChecked.Value;
bool parseMaxThreadsPerFile = !maxThreadsTextBox.Text.Equals("") && (int.Parse(maxThreadsTextBox.Text) <= Environment.ProcessorCount && int.Parse(maxThreadsTextBox.Text) > 0);
CommonParameters commonParamsToSave = new CommonParameters(
taskDescriptor: OutputFileNameTextBox.Text != "" ? OutputFileNameTextBox.Text : "SearchTask",
maxThreadsToUsePerFile: parseMaxThreadsPerFile ? int.Parse(maxThreadsTextBox.Text, CultureInfo.InvariantCulture) : new CommonParameters().MaxThreadsToUsePerFile,
useDeltaScore: deltaScoreCheckBox.IsChecked.Value,
reportAllAmbiguity: allAmbiguity.IsChecked.Value,
deconvolutionMaxAssumedChargeState: int.Parse(DeconvolutionMaxAssumedChargeStateTextBox.Text, CultureInfo.InvariantCulture),
totalPartitions: int.Parse(numberOfDatabaseSearchesTextBox.Text, CultureInfo.InvariantCulture),
doPrecursorDeconvolution: deconvolutePrecursors.IsChecked.Value,
useProvidedPrecursorInfo: useProvidedPrecursor.IsChecked.Value,
scoreCutoff: double.Parse(minScoreAllowed.Text, CultureInfo.InvariantCulture),
listOfModsFixed: listOfModsFixed,
listOfModsVariable: listOfModsVariable,
dissociationType: dissociationType,
precursorMassTolerance: PrecursorMassTolerance,
productMassTolerance: ProductMassTolerance,
digestionParams: digestionParamsToSave,
trimMs1Peaks: TrimMs1Peaks,
trimMsMsPeaks: TrimMsMsPeaks,
numberOfPeaksToKeepPerWindow: numPeaksToKeep,
minimumAllowedIntensityRatioToBasePeak: minimumAllowedIntensityRatioToBasePeak,
windowWidthThomsons: windowWidthThompsons,
numberOfWindows: numberOfWindows, //maybe change this some day
normalizePeaksAccrossAllWindows: normalizePeaksAccrossAllWindows, //maybe change this some day
addCompIons: addCompIonCheckBox.IsChecked.Value,
qValueOutputFilter: QValueCheckBox.IsChecked.Value ? double.Parse(QValueTextBox.Text, CultureInfo.InvariantCulture) : 1.0,
assumeOrphanPeaksAreZ1Fragments: protease.Name != "top-down",
minVariantDepth: MinVariantDepth,
maxHeterozygousVariants: MaxHeterozygousVariants);
if (classicSearchRadioButton.IsChecked.Value)
{
TheTask.SearchParameters.SearchType = SearchType.Classic;
}
else if (modernSearchRadioButton.IsChecked.Value)
{
TheTask.SearchParameters.SearchType = SearchType.Modern;
}
else //both semi and nonspecific are termed "nonspecific", because they both contain at least one nonspecific cleavage and they share the same algorithm
{
TheTask.SearchParameters.SearchType = SearchType.NonSpecific;
}
TheTask.SearchParameters.DoParsimony = checkBoxParsimony.IsChecked.Value;
TheTask.SearchParameters.NoOneHitWonders = checkBoxNoOneHitWonders.IsChecked.Value;
TheTask.SearchParameters.DoQuantification = !checkBoxNoQuant.IsChecked.Value;
//SilacLabel deconvolution
{
if (StaticSilacLabelsObservableCollection.Count == 0)
{
TheTask.SearchParameters.SilacLabels = null;
}
else
{
List <Proteomics.SilacLabel> labelsToSave = new List <Proteomics.SilacLabel>();
foreach (SilacInfoForDataGrid info in StaticSilacLabelsObservableCollection)
{
Proteomics.SilacLabel labelToAdd = info.SilacLabel[0];
//This is needed to prevent double adding of additional labels.
//A quick test is to create a silac condition with two labels, save, reopen the task, save, and reopen again.
//Without this line, the second label will be doubled (K+8)&(R+10)&(R+10)
if (labelToAdd.AdditionalLabels != null)
{
labelToAdd.AdditionalLabels.Clear();
}
for (int infoIndex = 1; infoIndex < info.SilacLabel.Count; infoIndex++)
{
labelToAdd.AddAdditionalSilacLabel(info.SilacLabel[infoIndex]);
}
labelsToSave.Add(labelToAdd);
}
TheTask.SearchParameters.SilacLabels = labelsToSave;
}
}
TheTask.SearchParameters.Normalize = checkBoxNormalize.IsChecked.Value;
TheTask.SearchParameters.MatchBetweenRuns = checkBoxMatchBetweenRuns.IsChecked.Value;
TheTask.SearchParameters.ModPeptidesAreDifferent = modPepsAreUnique.IsChecked.Value;
TheTask.SearchParameters.QuantifyPpmTol = double.Parse(peakFindingToleranceTextBox.Text, CultureInfo.InvariantCulture);
TheTask.SearchParameters.SearchTarget = checkBoxTarget.IsChecked.Value;
TheTask.SearchParameters.WriteMzId = ckbMzId.IsChecked.Value;
TheTask.SearchParameters.WriteDecoys = writeDecoyCheckBox.IsChecked.Value;
TheTask.SearchParameters.WriteContaminants = writeContaminantCheckBox.IsChecked.Value;
//TheTask.SearchParameters.OutPepXML = ckbPepXML.IsChecked.Value;
if (checkBoxDecoy.IsChecked.Value)
{
if (radioButtonReverseDecoy.IsChecked.Value)
{
TheTask.SearchParameters.DecoyType = DecoyType.Reverse;
}
else //if (radioButtonSlideDecoy.IsChecked.Value)
{
TheTask.SearchParameters.DecoyType = DecoyType.Slide;
}
}
else
{
TheTask.SearchParameters.DecoyType = DecoyType.None;
}
if (massDiffAcceptExact.IsChecked.HasValue && massDiffAcceptExact.IsChecked.Value)
{
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.Exact;
}
if (massDiffAccept1mm.IsChecked.HasValue && massDiffAccept1mm.IsChecked.Value)
{
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.OneMM;
}
if (massDiffAccept2mm.IsChecked.HasValue && massDiffAccept2mm.IsChecked.Value)
{
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.TwoMM;
}
if (massDiffAccept3mm.IsChecked.HasValue && massDiffAccept3mm.IsChecked.Value)
{
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.ThreeMM;
}
if (massDiffAccept187.IsChecked.HasValue && massDiffAccept187.IsChecked.Value)
{
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.ModOpen;
}
if (massDiffAcceptOpen.IsChecked.HasValue && massDiffAcceptOpen.IsChecked.Value)
{
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.Open;
}
if (massDiffAcceptCustom.IsChecked.HasValue && massDiffAcceptCustom.IsChecked.Value)
{
try
{
MassDiffAcceptor customMassDiffAcceptor = SearchTask.GetMassDiffAcceptor(null, MassDiffAcceptorType.Custom, customkMdacTextBox.Text);
}
catch (Exception ex)
{
MessageBox.Show("Could not parse custom mass difference acceptor: " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
TheTask.SearchParameters.MassDiffAcceptorType = MassDiffAcceptorType.Custom;
TheTask.SearchParameters.CustomMdac = customkMdacTextBox.Text;
}
//determine if semi or nonspecific with a specific protease.
if (searchModeType == CleavageSpecificity.Semi || protease.CleavageSpecificity == CleavageSpecificity.Semi)
{
TheTask.SearchParameters.LocalFdrCategories = new List <FdrCategory> {
FdrCategory.FullySpecific, FdrCategory.SemiSpecific
};
}
else if (searchModeType == CleavageSpecificity.None && protease.CleavageSpecificity != CleavageSpecificity.None)
{
TheTask.SearchParameters.LocalFdrCategories = new List <FdrCategory> {
FdrCategory.FullySpecific, FdrCategory.SemiSpecific, FdrCategory.NonSpecific
};
}
else
{
TheTask.SearchParameters.LocalFdrCategories = new List <FdrCategory> {
FdrCategory.FullySpecific
};
}
// displays warning if classic search is enabled with an open search mode
if (TheTask.SearchParameters.SearchType == SearchType.Classic &&
(TheTask.SearchParameters.MassDiffAcceptorType == MassDiffAcceptorType.ModOpen || TheTask.SearchParameters.MassDiffAcceptorType == MassDiffAcceptorType.Open))
{
MessageBoxResult result = MessageBox.Show("Modern Search mode is recommended when conducting open precursor mass searches to reduce search time.\n\n" +
"Continue anyway?", "Modern search recommended", MessageBoxButton.OKCancel);
if (result == MessageBoxResult.Cancel)
{
return;
}
}
TheTask.SearchParameters.DoHistogramAnalysis = checkBoxHistogramAnalysis.IsChecked.Value;
TheTask.SearchParameters.HistogramBinTolInDaltons = double.Parse(histogramBinWidthTextBox.Text, CultureInfo.InvariantCulture);
TheTask.SearchParameters.WritePrunedDatabase = writePrunedDBCheckBox.IsChecked.Value;
SetModSelectionForPrunedDB();
TheTask.CommonParameters = commonParamsToSave;
DialogResult = true;
}
public static void TestCompIons_ModernSearch()
{
var myMsDataFile = new TestDataFile();
var variableModifications = new List <ModificationWithMass>();
var fixedModifications = new List <ModificationWithMass>();
var localizeableModifications = new List <ModificationWithMass>();
Dictionary <ModificationWithMass, ushort> modsDictionary = new Dictionary <ModificationWithMass, ushort>();
foreach (var mod in fixedModifications)
{
modsDictionary.Add(mod, 0);
}
int ii = 1;
foreach (var mod in variableModifications)
{
modsDictionary.Add(mod, (ushort)ii);
ii++;
}
foreach (var mod in localizeableModifications)
{
modsDictionary.Add(mod, (ushort)ii);
ii++;
}
var proteinList = new List <Protein> {
new Protein("MNNNKQQQ", null)
};
SearchParameters SearchParameters = new SearchParameters
{
MassDiffAcceptorType = MassDiffAcceptorType.Exact,
SearchTarget = true,
};
CommonParameters CommonParameters = new CommonParameters
{
PrecursorMassTolerance = new PpmTolerance(5),
DigestionParams = new DigestionParams
{
Protease = new Protease("singleN", new List <string> {
"K"
}, new List <string>(), TerminusType.C, CleavageSpecificity.Full, null, null, null),
MinPeptideLength = null,
},
ConserveMemory = false,
ScoreCutoff = 1,
};
var indexEngine = new IndexingEngine(proteinList, variableModifications, fixedModifications, new List <ProductType> {
ProductType.B, ProductType.Y
}, 1, DecoyType.Reverse, new List <IDigestionParams> {
CommonParameters.DigestionParams
}, CommonParameters, SearchParameters.MaxFragmentSize, new List <string>());
var indexResults = (IndexingResults)indexEngine.Run();
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();
MassDiffAcceptor massDiffAcceptor = SearchTask.GetMassDiffAcceptor(CommonParameters.PrecursorMassTolerance, SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
PeptideSpectralMatch[] allPsmsArray = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
new ModernSearchEngine(allPsmsArray, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, new List <ProductType> {
ProductType.B, ProductType.Y
}, 0, CommonParameters, SearchParameters.AddCompIons, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, new List <string>()).Run();
PeptideSpectralMatch[] allPsmsArray2 = new PeptideSpectralMatch[listOfSortedms2Scans.Length];
SearchParameters.AddCompIons = true;
new ModernSearchEngine(allPsmsArray2, listOfSortedms2Scans, indexResults.PeptideIndex, indexResults.FragmentIndex, new List <ProductType> {
ProductType.B, ProductType.Y
}, 0, CommonParameters, SearchParameters.AddCompIons, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, new List <string>()).Run();
// Single search mode
Assert.AreEqual(allPsmsArray.Length, allPsmsArray2.Length);
// Single ms2 scan
Assert.AreEqual(allPsmsArray.Length, allPsmsArray2.Length);
Assert.That(allPsmsArray[0] != null);
Assert.That(allPsmsArray2[0] != null);
Assert.IsTrue(allPsmsArray2[0].Score > 1);
Assert.AreEqual(allPsmsArray[0].ScanNumber, allPsmsArray2[0].ScanNumber);
Assert.IsTrue(allPsmsArray2[0].Score <= allPsmsArray[0].Score * 2 && allPsmsArray2[0].Score > allPsmsArray[0].Score + 3);
}
private DataPointAquisitionResults GetDataAcquisitionResults(MsDataFile myMsDataFile, string currentDataFile, List <ModificationWithMass> variableModifications, List <ModificationWithMass> fixedModifications, List <Protein> proteinList, string taskId, CommonParameters combinedParameters, Tolerance initPrecTol, Tolerance initProdTol)
{
var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(currentDataFile);
MassDiffAcceptor searchMode = initPrecTol is PpmTolerance ?
(MassDiffAcceptor) new SinglePpmAroundZeroSearchMode(initPrecTol.Value) :
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> productTypes = new List <ProductType>();
if (combinedParameters.BIons)
{
productTypes.Add(ProductType.B);
}
if (combinedParameters.YIons)
{
productTypes.Add(ProductType.Y);
}
if (combinedParameters.CIons)
{
productTypes.Add(ProductType.C);
}
if (combinedParameters.ZdotIons)
{
productTypes.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, productTypes, searchMode, combinedParameters, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
List <PeptideSpectralMatch> allPsms = allPsmsArray.Where(p => p != null).ToList();
var compactPeptideToProteinPeptideMatching = ((SequencesToActualProteinPeptidesEngineResults) new SequencesToActualProteinPeptidesEngine
(allPsms, proteinList, fixedModifications, variableModifications, productTypes, new List <DigestionParams> {
combinedParameters.DigestionParams
},
combinedParameters.ReportAllAmbiguity, combinedParameters, new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run()).CompactPeptideToProteinPeptideMatching;
foreach (var huh in allPsms)
{
huh.MatchToProteinLinkedPeptides(compactPeptideToProteinPeptideMatching);
}
allPsms = allPsms.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, CommonParameters, 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())
{
return(new DataPointAquisitionResults(null, new List <PeptideSpectralMatch>(), new List <LabeledDataPoint>(), new List <LabeledDataPoint>(), 0, 0, 0, 0));
}
DataPointAquisitionResults currentResult = (DataPointAquisitionResults) new DataPointAcquisitionEngine(
goodIdentifications,
myMsDataFile,
initPrecTol,
initProdTol,
CalibrationParameters.NumFragmentsNeededForEveryIdentification,
CalibrationParameters.MinMS1IsotopicPeaksNeededForConfirmedIdentification,
CalibrationParameters.MinMS2IsotopicPeaksNeededForConfirmedIdentification,
fragmentTypesForCalibration,
CommonParameters,
new List <string> {
taskId, "Individual Spectra Files", fileNameWithoutExtension
}).Run();
return(currentResult);
}
private Tuple <int, PeptideWithSetModifications> Accepts(List <Product> fragments, double scanPrecursorMass, PeptideWithSetModifications peptide, FragmentationTerminus fragmentationTerminus, MassDiffAcceptor searchMode, bool semiSpecificSearch)
{
int localminPeptideLength = CommonParameters.DigestionParams.MinPeptideLength;
//Get terminal modifications, if any
Dictionary <int, List <Modification> > databaseAnnotatedMods = semiSpecificSearch ? null : GetTerminalModPositions(peptide, CommonParameters.DigestionParams, VariableTerminalModifications);
for (int i = localminPeptideLength - 1; i < fragments.Count; i++) //minus one start, because fragment 1 is at index 0
{
Product fragment = fragments[i];
double theoMass = fragment.NeutralMass - DissociationTypeCollection.GetMassShiftFromProductType(fragment.ProductType) + WaterMonoisotopicMass;
int notch = searchMode.Accepts(scanPrecursorMass, theoMass);
//check for terminal mods that might reach the observed mass
Modification terminalMod = null;
if (!semiSpecificSearch && notch < 0 && databaseAnnotatedMods.TryGetValue(i + 1, out List <Modification> terminalModsAtThisIndex)) //look for i+1, because the mod might exist at the terminus
{
foreach (Modification mod in terminalModsAtThisIndex)
{
notch = searchMode.Accepts(scanPrecursorMass, theoMass + mod.MonoisotopicMass.Value); //overwrite the notch, since the other notch wasn't accepted
if (notch >= 0)
{
terminalMod = mod;
break;
}
}
}
if (notch >= 0)
{
PeptideWithSetModifications updatedPwsm = null;
if (fragmentationTerminus == FragmentationTerminus.N)
{
int endResidue = peptide.OneBasedStartResidueInProtein + fragment.TerminusFragment.FragmentNumber - 1; //-1 for one based index
Dictionary <int, Modification> updatedMods = new Dictionary <int, Modification>();
foreach (KeyValuePair <int, Modification> mod in peptide.AllModsOneIsNterminus)
{
if (mod.Key < endResidue - peptide.OneBasedStartResidueInProtein + 3) //check if we cleaved it off, +1 for N-terminus being mod 1 and first residue being mod 2, +1 again for the -1 on end residue for one based index, +1 (again) for the one-based start residue
{
updatedMods.Add(mod.Key, mod.Value);
}
}
if (terminalMod != null)
{
updatedMods.Add(endResidue, terminalMod);
}
updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, peptide.OneBasedStartResidueInProtein, endResidue, CleavageSpecificity.Unknown, "", 0, updatedMods, 0);
}
else //if C terminal ions, shave off the n-terminus
{
int startResidue = peptide.OneBasedEndResidueInProtein - fragment.TerminusFragment.FragmentNumber + 1; //plus one for one based index
Dictionary <int, Modification> updatedMods = new Dictionary <int, Modification>(); //updateMods
int indexShift = startResidue - peptide.OneBasedStartResidueInProtein;
foreach (KeyValuePair <int, Modification> mod in peptide.AllModsOneIsNterminus)
{
if (mod.Key > indexShift + 1) //check if we cleaved it off, +1 for N-terminus being mod 1 and first residue being 2
{
int key = mod.Key - indexShift;
updatedMods.Add(key, mod.Value);
}
}
if (terminalMod != null)
{
updatedMods.Add(startResidue - 1, terminalMod);
}
updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, startResidue, peptide.OneBasedEndResidueInProtein, CleavageSpecificity.Unknown, "", 0, updatedMods, 0);
}
return(new Tuple <int, PeptideWithSetModifications>(notch, updatedPwsm));
}
else if (theoMass > scanPrecursorMass)
{
break;
}
}
//if the theoretical and experimental have the same mass or a terminal mod exists
if (peptide.BaseSequence.Length >= localminPeptideLength)
{
double totalMass = peptide.MonoisotopicMass;// + Constants.ProtonMass;
int notch = searchMode.Accepts(scanPrecursorMass, totalMass);
if (notch >= 0)
{
//need to update so that the cleavage specificity is recorded
PeptideWithSetModifications updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, peptide.OneBasedStartResidueInProtein, peptide.OneBasedEndResidueInProtein, CleavageSpecificity.Unknown, "", 0, peptide.AllModsOneIsNterminus, peptide.NumFixedMods);
return(new Tuple <int, PeptideWithSetModifications>(notch, updatedPwsm));
}
else //try a terminal mod (if it exists)
{
if (!semiSpecificSearch && databaseAnnotatedMods.TryGetValue(peptide.Length, out List <Modification> terminalModsAtThisIndex))
{
foreach (Modification terminalMod in terminalModsAtThisIndex)
{
notch = searchMode.Accepts(scanPrecursorMass, totalMass + terminalMod.MonoisotopicMass.Value); //overwrite the notch, since the other notch wasn't accepted
if (notch >= 0)
{
//need to update the mod dictionary and don't want to overwrite the peptide incase it's in other scans
Dictionary <int, Modification> updatedMods = new Dictionary <int, Modification>(); //updateMods
foreach (KeyValuePair <int, Modification> mod in peptide.AllModsOneIsNterminus)
{
updatedMods.Add(mod.Key, mod.Value);
}
//add the terminal mod
if (fragmentationTerminus == FragmentationTerminus.N)
{
updatedMods[peptide.OneBasedEndResidueInProtein] = terminalMod;
}
else
{
updatedMods[peptide.OneBasedStartResidueInProtein - 1] = terminalMod;
}
PeptideWithSetModifications updatedPwsm = new PeptideWithSetModifications(peptide.Protein, peptide.DigestionParams, peptide.OneBasedStartResidueInProtein, peptide.OneBasedEndResidueInProtein, CleavageSpecificity.Unknown, "", 0, updatedMods, peptide.NumFixedMods);
return(new Tuple <int, PeptideWithSetModifications>(notch, updatedPwsm));
}
}
}
}
}
return(new Tuple <int, PeptideWithSetModifications>(-1, null));
}
public SearchModeForDataGrid(MassDiffAcceptor searchMode)
{
this.searchMode = searchMode;
}
protected override MetaMorpheusEngineResults RunSpecific()
{
bool semiSpecificSearch = CommonParameters.DigestionParams.SearchModeType == CleavageSpecificity.Semi;
double progress = 0;
int oldPercentProgress = 0;
ReportProgress(new ProgressEventArgs(oldPercentProgress, "Performing nonspecific search... " + CurrentPartition + "/" + CommonParameters.TotalPartitions, NestedIds));
byte byteScoreCutoff = (byte)CommonParameters.ScoreCutoff;
int maxThreadsPerFile = CommonParameters.MaxThreadsToUsePerFile;
int[] threads = Enumerable.Range(0, maxThreadsPerFile).ToArray();
Parallel.ForEach(threads, (i) =>
{
byte[] scoringTable = new byte[PeptideIndex.Count];
HashSet <int> idsOfPeptidesPossiblyObserved = new HashSet <int>();
for (; i < ListOfSortedMs2Scans.Length; i += maxThreadsPerFile)
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
return;
}
// empty the scoring table to score the new scan (conserves memory compared to allocating a new array)
Array.Clear(scoringTable, 0, scoringTable.Length);
idsOfPeptidesPossiblyObserved.Clear();
Ms2ScanWithSpecificMass scan = ListOfSortedMs2Scans[i];
//get bins to add points to
List <int> allBinsToSearch = GetBinsToSearch(scan, FragmentIndex, CommonParameters.DissociationType);
//the entire indexed scoring is done here
for (int j = 0; j < allBinsToSearch.Count; j++)
{
FragmentIndex[allBinsToSearch[j]].ForEach(id => scoringTable[id]++);
}
//populate ids of possibly observed with those containing allowed precursor masses
List <AllowedIntervalWithNotch> validIntervals = MassDiffAcceptor.GetAllowedPrecursorMassIntervalsFromObservedMass(scan.PrecursorMass).ToList(); //get all valid notches
foreach (AllowedIntervalWithNotch interval in validIntervals)
{
int obsPrecursorFloorMz = (int)Math.Floor(interval.AllowedInterval.Minimum * FragmentBinsPerDalton);
int obsPrecursorCeilingMz = (int)Math.Ceiling(interval.AllowedInterval.Maximum * FragmentBinsPerDalton);
foreach (ProductType pt in ProductTypesToSearch)
{
int dissociationBinShift = (int)Math.Round((WaterMonoisotopicMass - DissociationTypeCollection.GetMassShiftFromProductType(pt)) * FragmentBinsPerDalton);
int lowestBin = obsPrecursorFloorMz - dissociationBinShift;
int highestBin = obsPrecursorCeilingMz - dissociationBinShift;
for (int bin = lowestBin; bin <= highestBin; bin++)
{
if (bin < FragmentIndex.Length && FragmentIndex[bin] != null)
{
FragmentIndex[bin].ForEach(id => idsOfPeptidesPossiblyObserved.Add(id));
}
}
}
for (int bin = obsPrecursorFloorMz; bin <= obsPrecursorCeilingMz; bin++) //no bin shift, since they're precursor masses
{
if (bin < PrecursorIndex.Length && PrecursorIndex[bin] != null)
{
PrecursorIndex[bin].ForEach(id => idsOfPeptidesPossiblyObserved.Add(id));
}
}
}
// done with initial scoring; refine scores and create PSMs
if (idsOfPeptidesPossiblyObserved.Any())
{
int maxInitialScore = idsOfPeptidesPossiblyObserved.Max(id => scoringTable[id]) + 1;
while (maxInitialScore > CommonParameters.ScoreCutoff) //go through all until we hit the end
{
maxInitialScore--;
foreach (int id in idsOfPeptidesPossiblyObserved.Where(id => scoringTable[id] == maxInitialScore))
{
PeptideWithSetModifications peptide = PeptideIndex[id];
List <Product> peptideTheorProducts = peptide.Fragment(CommonParameters.DissociationType, CommonParameters.DigestionParams.FragmentationTerminus).ToList();
Tuple <int, PeptideWithSetModifications> notchAndUpdatedPeptide = Accepts(peptideTheorProducts, scan.PrecursorMass, peptide, CommonParameters.DigestionParams.FragmentationTerminus, MassDiffAcceptor, semiSpecificSearch);
int notch = notchAndUpdatedPeptide.Item1;
if (notch >= 0)
{
peptide = notchAndUpdatedPeptide.Item2;
peptideTheorProducts = peptide.Fragment(CommonParameters.DissociationType, FragmentationTerminus.Both).ToList();
List <MatchedFragmentIon> matchedIons = MatchFragmentIons(scan, peptideTheorProducts, ModifiedParametersNoComp);
double thisScore = CalculatePeptideScore(scan.TheScan, matchedIons);
if (thisScore > CommonParameters.ScoreCutoff)
{
PeptideSpectralMatch[] localPeptideSpectralMatches = GlobalCategorySpecificPsms[(int)FdrClassifier.GetCleavageSpecificityCategory(peptide.CleavageSpecificityForFdrCategory)];
if (localPeptideSpectralMatches[i] == null)
{
localPeptideSpectralMatches[i] = new PeptideSpectralMatch(peptide, notch, thisScore, i, scan, CommonParameters.DigestionParams, matchedIons);
}
else
{
localPeptideSpectralMatches[i].AddOrReplace(peptide, thisScore, notch, CommonParameters.ReportAllAmbiguity, matchedIons, 0);
}
}
}
}
}
}
// report search progress
progress++;
int percentProgress = (int)((progress / ListOfSortedMs2Scans.Length) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Performing nonspecific search... " + CurrentPartition + "/" + CommonParameters.TotalPartitions, NestedIds));
}
}
});
return(new MetaMorpheusEngineResults(this));
}
protected override MetaMorpheusEngineResults RunSpecific()
{
double progress = 0;
int oldPercentProgress = 0;
ReportProgress(new ProgressEventArgs(oldPercentProgress, "Performing crosslink search... " + CurrentPartition + "/" + CommonParameters.TotalPartitions, NestedIds));
byte byteScoreCutoff = (byte)CommonParameters.ScoreCutoff;
int maxThreadsPerFile = CommonParameters.MaxThreadsToUsePerFile;
int[] threads = Enumerable.Range(0, maxThreadsPerFile).ToArray();
Parallel.ForEach(threads, (scanIndex) =>
{
byte[] scoringTable = new byte[PeptideIndex.Count];
List <int> idsOfPeptidesPossiblyObserved = new List <int>();
for (; scanIndex < ListOfSortedMs2Scans.Length; scanIndex += maxThreadsPerFile)
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
return;
}
// empty the scoring table to score the new scan (conserves memory compared to allocating a new array)
Array.Clear(scoringTable, 0, scoringTable.Length);
idsOfPeptidesPossiblyObserved.Clear();
var scan = ListOfSortedMs2Scans[scanIndex];
// get fragment bins for this scan
List <int> allBinsToSearch = GetBinsToSearch(scan);
List <BestPeptideScoreNotch> bestPeptideScoreNotchList = new List <BestPeptideScoreNotch>();
// first-pass scoring
IndexedScoring(allBinsToSearch, scoringTable, byteScoreCutoff, idsOfPeptidesPossiblyObserved, scan.PrecursorMass, Double.NegativeInfinity, Double.PositiveInfinity, PeptideIndex, MassDiffAcceptor, 0, CommonParameters.DissociationType);
// done with indexed scoring; refine scores and create PSMs
if (idsOfPeptidesPossiblyObserved.Any())
{
if (CrosslinkSearchTopN)
{
// take top N hits for this scan
idsOfPeptidesPossiblyObserved = idsOfPeptidesPossiblyObserved.OrderByDescending(p => scoringTable[p]).Take(TopN).ToList();
}
foreach (var id in idsOfPeptidesPossiblyObserved)
{
PeptideWithSetModifications peptide = PeptideIndex[id];
int notch = MassDiffAcceptor.Accepts(scan.PrecursorMass, peptide.MonoisotopicMass);
bestPeptideScoreNotchList.Add(new BestPeptideScoreNotch(peptide, scoringTable[id], notch));
}
// combine individual peptide hits with crosslinker mass to find best crosslink PSM hit
var csm = FindCrosslinkedPeptide(scan, bestPeptideScoreNotchList, scanIndex);
if (csm == null)
{
progress++;
continue;
}
// this scan might already have a hit from a different database partition; check to see if the score improves
if (GlobalCsms[scanIndex] == null || GlobalCsms[scanIndex].XLTotalScore < csm.XLTotalScore)
{
GlobalCsms[scanIndex] = csm;
}
}
// report search progress
progress++;
var percentProgress = (int)((progress / ListOfSortedMs2Scans.Length) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Performing crosslink search... " + CurrentPartition + "/" + CommonParameters.TotalPartitions, NestedIds));
}
}
});
return(new MetaMorpheusEngineResults(this));
}
private int ComputePeptideIndexes(PeptideWithSetModifications yyy, double[] prevMass, int oneBasedIndexToLookAt, int direction, double precursorMass, MassDiffAcceptor massDiffAcceptor)
{
ModificationWithMass residue_variable_mod = null;
do
{
prevMass[0] += Residue.ResidueMonoisotopicMass[yyy[oneBasedIndexToLookAt - 1]];
yyy.allModsOneIsNterminus.TryGetValue(oneBasedIndexToLookAt + 1, out residue_variable_mod);
if (residue_variable_mod == null)
{
if (massDiffAcceptor.Accepts(precursorMass, prevMass[0]) >= 0)
{
return(oneBasedIndexToLookAt);
}
}
else if (residue_variable_mod.neutralLosses.Count == 1)
{
prevMass[0] += residue_variable_mod.monoisotopicMass - residue_variable_mod.neutralLosses.First();
if (massDiffAcceptor.Accepts(precursorMass, prevMass[0]) >= 0)
{
return(oneBasedIndexToLookAt);
}
}
else
{
foreach (double nl in residue_variable_mod.neutralLosses)
{
prevMass[0] = prevMass[0] + residue_variable_mod.monoisotopicMass - nl;
if (massDiffAcceptor.Accepts(precursorMass, prevMass[0]) >= 0)
{
return(oneBasedIndexToLookAt);
}
if ((direction == 1 && oneBasedIndexToLookAt + direction < yyy.Length) ||
(direction == -1 && oneBasedIndexToLookAt + direction > 1))
{
return(ComputePeptideIndexes(yyy, prevMass, oneBasedIndexToLookAt + direction, direction, precursorMass, massDiffAcceptor));
}
}
break;
}
oneBasedIndexToLookAt += direction;
} while ((oneBasedIndexToLookAt >= 1 && direction == -1) || (oneBasedIndexToLookAt <= yyy.Length && direction == 1));
return(-1);
}
private Tuple <int, double> Accepts(double scanPrecursorMass, CompactPeptide peptide, TerminusType terminusType, MassDiffAcceptor searchMode)
{
//all masses in N and CTerminalMasses are b-ion masses, which are one water away from a full peptide
int localminPeptideLength = CommonParameters.DigestionParams.MinPeptideLength ?? 0;
if (terminusType == TerminusType.N)
{
for (int i = localminPeptideLength; i < peptide.NTerminalMasses.Count(); i++)
{
double theoMass = peptide.NTerminalMasses[i] + waterMonoisotopicMass;
int notch = searchMode.Accepts(scanPrecursorMass, theoMass);
if (notch >= 0)
{
return(new Tuple <int, double>(notch, theoMass));
}
else if (theoMass > scanPrecursorMass)
{
break;
}
}
//if the theoretical and experimental have the same mass
if (peptide.NTerminalMasses.Count() > localminPeptideLength)
{
double totalMass = peptide.MonoisotopicMassIncludingFixedMods;// + Constants.protonMass;
int notch = searchMode.Accepts(scanPrecursorMass, totalMass);
if (notch >= 0)
{
return(new Tuple <int, double>(notch, totalMass));
}
}
}
else//if (terminusType==TerminusType.C)
{
for (int i = localminPeptideLength; i < peptide.CTerminalMasses.Count(); i++)
{
double theoMass = peptide.CTerminalMasses[i] + waterMonoisotopicMass;
int notch = searchMode.Accepts(scanPrecursorMass, theoMass);
if (notch >= 0)
{
return(new Tuple <int, double>(notch, theoMass));
}
else if (theoMass > scanPrecursorMass)
{
break;
}
}
//if the theoretical and experimental have the same mass
if (peptide.CTerminalMasses.Count() > localminPeptideLength)
{
double totalMass = peptide.MonoisotopicMassIncludingFixedMods;// + Constants.protonMass;
int notch = searchMode.Accepts(scanPrecursorMass, totalMass);
if (notch >= 0)
{
return(new Tuple <int, double>(notch, totalMass));
}
}
}
return(new Tuple <int, double>(-1, -1));
}
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 NonSpecificEnzymeSearchEngine(PeptideSpectralMatch[] globalPsms, Ms2ScanWithSpecificMass[] listOfSortedms2Scans, List <CompactPeptide> peptideIndex, List <int>[] fragmentIndex, List <int>[] fragmentIndexPrecursor, List <ProductType> lp, int currentPartition, ICommonParameters CommonParameters, bool addCompIons, MassDiffAcceptor massDiffAcceptor, double maximumMassThatFragmentIonScoreIsDoubled, List <string> nestedIds) : base(globalPsms, listOfSortedms2Scans, peptideIndex, fragmentIndex, lp, currentPartition, CommonParameters, addCompIons, massDiffAcceptor, maximumMassThatFragmentIonScoreIsDoubled, nestedIds)
{
this.fragmentIndexPrecursor = fragmentIndexPrecursor;
}
