public static void TestSeparateIonsByTerminus()
{
List <ProductType> allIonTypes = new List <ProductType> {
ProductType.b, ProductType.c, ProductType.zPlusOne, ProductType.y
};
List <List <ProductType> > separated = ProductTypeMethods.SeparateIonsByTerminus(allIonTypes);
Assert.IsTrue(separated.Count == 2);
Assert.IsTrue(separated[0].Count == 2);
Assert.IsTrue(separated[1].Count == 2);
Assert.IsTrue(separated[0].Contains(ProductType.b));
Assert.IsTrue(separated[0].Contains(ProductType.c));
Assert.IsTrue(separated[1].Contains(ProductType.y));
Assert.IsTrue(separated[1].Contains(ProductType.zPlusOne));
List <List <ProductType> > nOnly = ProductTypeMethods.SeparateIonsByTerminus(separated[0]);
Assert.IsTrue(nOnly.Count == 1);
Assert.IsTrue(nOnly[0].Count == 2);
Assert.IsTrue(nOnly[0].Contains(ProductType.b));
Assert.IsTrue(nOnly[0].Contains(ProductType.c));
List <List <ProductType> > cOnly = ProductTypeMethods.SeparateIonsByTerminus(separated[1]);
Assert.IsTrue(cOnly.Count == 1);
Assert.IsTrue(cOnly[0].Count == 2);
Assert.IsTrue(cOnly[0].Contains(ProductType.y));
Assert.IsTrue(cOnly[0].Contains(ProductType.zPlusOne));
}
public static void TestSeparateIonsByTerminus()
{
List <ProductType> allIonTypes = new List <ProductType> {
ProductType.B, ProductType.C, ProductType.Zdot, ProductType.Y
};
List <List <ProductType> > separated = ProductTypeMethods.SeparateIonsByTerminus(allIonTypes);
Assert.IsTrue(separated.Count == 2);
Assert.IsTrue(separated[0].Count == 2);
Assert.IsTrue(separated[1].Count == 2);
Assert.IsTrue(separated[0].Contains(ProductType.B));
Assert.IsTrue(separated[0].Contains(ProductType.C));
Assert.IsTrue(separated[1].Contains(ProductType.Y));
Assert.IsTrue(separated[1].Contains(ProductType.Zdot));
List <List <ProductType> > nOnly = ProductTypeMethods.SeparateIonsByTerminus(separated[0]);
Assert.IsTrue(nOnly.Count == 1);
Assert.IsTrue(nOnly[0].Count == 2);
Assert.IsTrue(nOnly[0].Contains(ProductType.B));
Assert.IsTrue(nOnly[0].Contains(ProductType.C));
List <List <ProductType> > cOnly = ProductTypeMethods.SeparateIonsByTerminus(separated[1]);
Assert.IsTrue(cOnly.Count == 1);
Assert.IsTrue(cOnly[0].Count == 2);
Assert.IsTrue(cOnly[0].Contains(ProductType.Y));
Assert.IsTrue(cOnly[0].Contains(ProductType.Zdot));
}
public static void ParsimonyLocalizeableTreatAsUnique()
{
bool modPeptidesAreUnique = true;
// set up mods
var modDictionary = new Dictionary <int, List <Modification> >();
ModificationMotif.TryGetMotif("M", out ModificationMotif motif1);
var mod = new ModificationWithMass("Oxidation of M", "Common Variable", motif1, TerminusLocalization.Any, 15.99491461957);
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(new List <ProductType> {
ProductType.B, ProductType.Y
});
Protease protease = new Protease("k protease", 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);
// modified version of protein
var protein1 = new Protein("PEPTIDEM", "accession1");
// unmodified version of protein
var protein2 = new Protein("YYYKPEPTIDEM", "accession2");
var pep1 = protein1.Digest(new DigestionParams(protease.Name, minPeptideLength: 1), new List <ModificationWithMass> {
mod
}, new List <ModificationWithMass>()).First();
var pep2 = protein2.Digest(new DigestionParams(protease.Name, minPeptideLength: 1), new List <ModificationWithMass>(), new List <ModificationWithMass>()).ToList()[1];
// check to make sure mod is present
Assert.That(pep1.Sequence != pep2.Sequence);
Assert.That(pep1.NumMods == 1);
Assert.That(pep2.NumMods == 0);
// build the dictionary for input to parsimony
var compactPeptideToProteinPeptideMatching = new Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> >();
compactPeptideToProteinPeptideMatching.Add(pep1.CompactPeptide(terminusType), new HashSet <PeptideWithSetModifications> {
pep1
});
compactPeptideToProteinPeptideMatching.Add(pep2.CompactPeptide(terminusType), new HashSet <PeptideWithSetModifications> {
pep2
});
// apply parsimony
ProteinParsimonyEngine pae = new ProteinParsimonyEngine(compactPeptideToProteinPeptideMatching, modPeptidesAreUnique, new CommonParameters(), new List <string>());
pae.Run();
// check to make sure both peptides are NOT associated with both proteins
Assert.That(compactPeptideToProteinPeptideMatching.Count == 2);
foreach (var kvp in compactPeptideToProteinPeptideMatching)
{
Assert.That(kvp.Value.Count == 1);
}
}
public SequencesToActualProteinPeptidesEngine(List <PeptideSpectralMatch> allPsms, List <Protein> proteinList, List <ModificationWithMass> fixedModifications, List <ModificationWithMass> variableModifications, List <ProductType> ionTypes, IEnumerable <DigestionParams> collectionOfDigestionParams, bool reportAllAmbiguity, CommonParameters commonParameters, List <string> nestedIds) : base(commonParameters, nestedIds)
{
Proteins = proteinList;
AllPsms = allPsms;
FixedModifications = fixedModifications;
VariableModifications = variableModifications;
TerminusType = ProductTypeMethods.IdentifyTerminusType(ionTypes);
CollectionOfDigestionParams = collectionOfDigestionParams;
ReportAllAmbiguity = reportAllAmbiguity;
}
protected override MetaMorpheusEngineResults RunSpecific()
{
Status("Getting ms2 scans...");
double proteinsSearched = 0;
int oldPercentProgress = 0;
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(ProductTypes);
// one lock for each MS2 scan; a scan can only be accessed by one thread at a time
var myLocks = new object[PeptideSpectralMatches.Length];
for (int i = 0; i < myLocks.Length; i++)
{
myLocks[i] = new object();
}
Status("Performing classic search...");
if (Proteins.Any())
{
Parallel.ForEach(Partitioner.Create(0, Proteins.Count), new ParallelOptions {
MaxDegreeOfParallelism = commonParameters.MaxThreadsToUsePerFile
}, (partitionRange, loopState) =>
{
for (int i = partitionRange.Item1; i < partitionRange.Item2; i++)
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
loopState.Stop();
return;
}
// digest each protein into peptides and search for each peptide in all spectra within precursor mass tolerance
foreach (var peptide in Proteins[i].Digest(commonParameters.DigestionParams, FixedModifications, VariableModifications))
{
var peptideTheorIons = peptide.GetTheoreticalFragments(ProductTypes);
var compactPeptide = peptide.CompactPeptide(terminusType);
foreach (ScanWithIndexAndNotchInfo scan in GetAcceptableScans(compactPeptide.MonoisotopicMassIncludingFixedMods, SearchMode))
{
var matchedIons = MatchFragmentIons(scan.TheScan.TheScan.MassSpectrum, peptideTheorIons, commonParameters);
if (commonParameters.AddCompIons)
{
foreach (var dissociationType in DissociationTypes)
{
MzSpectrum complementarySpectrum = GenerateComplementarySpectrum(scan.TheScan.TheScan.MassSpectrum, scan.TheScan.PrecursorMass, dissociationType);
matchedIons.AddRange(MatchFragmentIons(complementarySpectrum, peptideTheorIons, commonParameters));
}
}
double thisScore = CalculatePeptideScore(scan.TheScan.TheScan, matchedIons, 0);
bool meetsScoreCutoff = thisScore >= commonParameters.ScoreCutoff;
// this is thread-safe because even if the score improves from another thread writing to this PSM,
// the lock combined with AddOrReplace method will ensure thread safety
if (meetsScoreCutoff || commonParameters.CalculateEValue)
{
// valid hit (met the cutoff score); lock the scan to prevent other threads from accessing it
lock (myLocks[scan.ScanIndex])
{
bool scoreImprovement = PeptideSpectralMatches[scan.ScanIndex] == null || (thisScore - PeptideSpectralMatches[scan.ScanIndex].RunnerUpScore) > -PeptideSpectralMatch.ToleranceForScoreDifferentiation;
if (scoreImprovement)
{
if (PeptideSpectralMatches[scan.ScanIndex] == null)
{
PeptideSpectralMatches[scan.ScanIndex] = new PeptideSpectralMatch(compactPeptide, scan.Notch, thisScore, scan.ScanIndex, scan.TheScan, commonParameters.DigestionParams);
}
else
{
PeptideSpectralMatches[scan.ScanIndex].AddOrReplace(compactPeptide, thisScore, scan.Notch, commonParameters.ReportAllAmbiguity);
}
//TODO: move this into the PeptideSpectralMatch constructor
PeptideSpectralMatches[scan.ScanIndex].SetMatchedFragments(matchedIons);
}
if (commonParameters.CalculateEValue)
{
PeptideSpectralMatches[scan.ScanIndex].AllScores.Add(thisScore);
}
}
}
}
}
// report search progress (proteins searched so far out of total proteins in database)
proteinsSearched++;
var percentProgress = (int)((proteinsSearched / Proteins.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Performing classic search... ", nestedIds));
}
}
});
}
// remove peptides below the score cutoff that were stored to calculate expectation values
if (commonParameters.CalculateEValue)
{
for (int i = 0; i < PeptideSpectralMatches.Length; i++)
{
if (PeptideSpectralMatches[i] != null && PeptideSpectralMatches[i].Score < commonParameters.ScoreCutoff)
{
PeptideSpectralMatches[i] = null;
}
}
}
return(new MetaMorpheusEngineResults(this));
}
protected override MetaMorpheusEngineResults RunSpecific()
{
double progress = 0;
int oldPercentProgress = 0;
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(ProductTypes);
// digest database
HashSet <CompactPeptide> peptideToId = new HashSet <CompactPeptide>();
Parallel.ForEach(Partitioner.Create(0, ProteinList.Count), new ParallelOptions {
MaxDegreeOfParallelism = commonParameters.MaxThreadsToUsePerFile
}, (range, loopState) =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
loopState.Stop();
return;
}
foreach (var digestionParams in CollectionOfDigestionParams)
{
foreach (var pepWithSetMods in ProteinList[i].Digest(digestionParams, FixedModifications, VariableModifications))
{
CompactPeptide compactPeptide = pepWithSetMods.CompactPeptide(terminusType);
var observed = peptideToId.Contains(compactPeptide);
if (observed)
{
continue;
}
lock (peptideToId)
{
observed = peptideToId.Contains(compactPeptide);
if (observed)
{
continue;
}
peptideToId.Add(compactPeptide);
}
}
}
progress++;
var percentProgress = (int)((progress / ProteinList.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Digesting proteins for precursor...", nestedIds));
}
}
});
// sort peptides by mass
var peptidesSortedByMass = peptideToId.AsParallel().WithDegreeOfParallelism(commonParameters.MaxThreadsToUsePerFile).OrderBy(p => p.MonoisotopicMassIncludingFixedMods).ToList();
peptideToId = null;
// create fragment index
int maxFragmentMass = 0;
for (int i = peptidesSortedByMass.Count - 1; i >= 0; i--)
{
if (!Double.IsNaN(peptidesSortedByMass[i].MonoisotopicMassIncludingFixedMods))
{
maxFragmentMass = (int)Math.Ceiling(Chemistry.ClassExtensions.ToMz(peptidesSortedByMass[i].MonoisotopicMassIncludingFixedMods, 1));
break;
}
}
var fragmentIndex = new List <int> [maxFragmentMass * FragmentBinsPerDalton + 1];
// populate fragment index
progress = 0;
oldPercentProgress = 0;
for (int i = 0; i < peptidesSortedByMass.Count; i++)
{
double mz = Chemistry.ClassExtensions.ToMz(peptidesSortedByMass[i].MonoisotopicMassIncludingFixedMods, 1);
if (!Double.IsNaN(mz))
{
int fragmentBin = (int)Math.Round(mz * FragmentBinsPerDalton);
if (fragmentIndex[fragmentBin] == null)
{
fragmentIndex[fragmentBin] = new List <int> {
i
}
}
;
else
{
fragmentIndex[fragmentBin].Add(i);
}
}
progress++;
var percentProgress = (int)((progress / peptidesSortedByMass.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Creating fragment index for precursor...", nestedIds));
}
}
return(new IndexingResults(peptidesSortedByMass, fragmentIndex, this));
}
protected override MetaMorpheusEngineResults RunSpecific()
{
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(ProductTypes);
foreach (PeptideSpectralMatch psm in AllResultingIdentifications)
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
break;
}
psm.MatchedIonSeriesDict = new Dictionary <ProductType, int[]>();
psm.MatchedIonMassToChargeRatioDict = new Dictionary <ProductType, double[]>();
psm.ProductMassErrorDa = new Dictionary <ProductType, double[]>();
psm.ProductMassErrorPpm = new Dictionary <ProductType, double[]>();
psm.MatchedIonIntensitiesDict = new Dictionary <ProductType, double[]>();
var theScan = MyMsDataFile.GetOneBasedScan(psm.ScanNumber);
double thePrecursorMass = psm.ScanPrecursorMass;
foreach (ProductType productType in ProductTypes)
{
var sortedTheoreticalProductMasses = psm.CompactPeptides.First().Key.ProductMassesMightHaveDuplicatesAndNaNs(new List <ProductType> {
productType
});
Array.Sort(sortedTheoreticalProductMasses);
List <int> matchedIonSeriesList = new List <int>();
List <double> matchedIonMassToChargeRatioList = new List <double>();
List <double> productMassErrorDaList = new List <double>();
List <double> productMassErrorPpmList = new List <double>();
List <double> matchedIonIntensityList = new List <double>();
//populate the above lists
MatchIonsOld(theScan, commonParameters.ProductMassTolerance, sortedTheoreticalProductMasses, matchedIonSeriesList, matchedIonMassToChargeRatioList, productMassErrorDaList, productMassErrorPpmList, matchedIonIntensityList, thePrecursorMass, productType, commonParameters.AddCompIons);
psm.MatchedIonSeriesDict.Add(productType, matchedIonSeriesList.ToArray());
psm.MatchedIonMassToChargeRatioDict.Add(productType, matchedIonMassToChargeRatioList.ToArray());
psm.ProductMassErrorDa.Add(productType, productMassErrorDaList.ToArray());
psm.ProductMassErrorPpm.Add(productType, productMassErrorPpmList.ToArray());
psm.MatchedIonIntensitiesDict.Add(productType, matchedIonIntensityList.ToArray());
}
}
foreach (PeptideSpectralMatch psm in AllResultingIdentifications.Where(b => b.NumDifferentCompactPeptides == 1))
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
break;
}
var theScan = MyMsDataFile.GetOneBasedScan(psm.ScanNumber);
double thePrecursorMass = psm.ScanPrecursorMass;
if (psm.FullSequence == null)
{
continue;
}
PeptideWithSetModifications representative = psm.CompactPeptides.First().Value.Item2.First();
var localizedScores = new List <double>();
for (int indexToLocalize = 0; indexToLocalize < representative.Length; indexToLocalize++)
{
PeptideWithSetModifications localizedPeptide = representative.Localize(indexToLocalize, psm.ScanPrecursorMass - representative.MonoisotopicMass);
var gg = localizedPeptide.CompactPeptide(terminusType).ProductMassesMightHaveDuplicatesAndNaNs(ProductTypes);
Array.Sort(gg);
var score = CalculatePeptideScoreOld(theScan, commonParameters.ProductMassTolerance, gg, thePrecursorMass, DissociationTypes, commonParameters.AddCompIons, 0);
localizedScores.Add(score);
}
psm.LocalizedScores = localizedScores;
}
return(new LocalizationEngineResults(this));
}
protected override MyTaskResults RunSpecific(string OutputFolder, List <DbForTask> dbFilenameList, List <string> currentRawFileList, string taskId, FileSpecificParameters[] fileSettingsList)
{
MyTaskResults = new MyTaskResults(this);
List <PsmCross> allPsms = new List <PsmCross>();
var compactPeptideToProteinPeptideMatch = new Dictionary <CompactPeptideBase, HashSet <PeptideWithSetModifications> >();
Status("Loading modifications...", taskId);
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();
List <string> localizeableModificationTypes = GlobalVariables.AllModTypesKnown.ToList();
// load proteins
List <Protein> proteinList = LoadProteins(taskId, dbFilenameList, true, XlSearchParameters.DecoyType, localizeableModificationTypes, CommonParameters);
List <ProductType> ionTypes = new List <ProductType>();
if (CommonParameters.BIons)
{
ionTypes.Add(ProductType.BnoB1ions);
}
if (CommonParameters.YIons)
{
ionTypes.Add(ProductType.Y);
}
if (CommonParameters.ZdotIons)
{
ionTypes.Add(ProductType.Zdot);
}
if (CommonParameters.CIons)
{
ionTypes.Add(ProductType.C);
}
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(ionTypes);
var crosslinker = new CrosslinkerTypeClass();
crosslinker.SelectCrosslinker(XlSearchParameters.CrosslinkerType);
if (XlSearchParameters.CrosslinkerType == CrosslinkerType.UserDefined)
{
crosslinker = GenerateUserDefinedCrosslinker(XlSearchParameters);
}
MyFileManager myFileManager = new MyFileManager(XlSearchParameters.DisposeOfFileWhenDone);
var fileSpecificCommonParams = fileSettingsList.Select(b => SetAllFileSpecificCommonParams(CommonParameters, b));
HashSet <DigestionParams> ListOfDigestionParams = new HashSet <DigestionParams>(fileSpecificCommonParams.Select(p => p.DigestionParams));
int completedFiles = 0;
object indexLock = new object();
object psmLock = new object();
Status("Searching files...", taskId);
ProseCreatedWhileRunning.Append("The following crosslink discovery were used: ");
ProseCreatedWhileRunning.Append("crosslinker name = " + crosslinker.CrosslinkerName + "; ");
ProseCreatedWhileRunning.Append("crosslinker type = " + crosslinker.Cleavable + "; ");
ProseCreatedWhileRunning.Append("crosslinker mass = " + crosslinker.TotalMass + "; ");
ProseCreatedWhileRunning.Append("crosslinker modification site(s) = " + crosslinker.CrosslinkerModSites + "; ");
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("max modification isoforms = " + CommonParameters.DigestionParams.MaxModificationIsoforms + "; ");
ProseCreatedWhileRunning.Append("fixed modifications = " + string.Join(", ", fixedModifications.Select(m => m.id)) + "; ");
ProseCreatedWhileRunning.Append("variable modifications = " + string.Join(", ", variableModifications.Select(m => m.id)) + "; ");
ProseCreatedWhileRunning.Append("parent mass tolerance(s) = " + XlSearchParameters.XlPrecusorMsTl + "; ");
ProseCreatedWhileRunning.Append("product mass tolerance = " + CommonParameters.ProductMassTolerance + "; ");
ProseCreatedWhileRunning.Append("The combined search database contained " + proteinList.Count + " total entries including " + proteinList.Where(p => p.IsContaminant).Count() + " contaminant sequences. ");
for (int spectraFileIndex = 0; spectraFileIndex < currentRawFileList.Count; spectraFileIndex++)
{
if (GlobalVariables.StopLoops)
{
break;
}
var origDataFile = currentRawFileList[spectraFileIndex];
CommonParameters combinedParams = SetAllFileSpecificCommonParams(CommonParameters, fileSettingsList[spectraFileIndex]);
List <PsmCross> newPsms = new List <PsmCross>();
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.TopNpeaks, combinedParams.MinRatio, combinedParams.TrimMs1Peaks, combinedParams.TrimMsMsPeaks, combinedParams);
Status("Getting ms2 scans...", thisId);
Ms2ScanWithSpecificMass[] arrayOfMs2ScansSortedByMass = GetMs2Scans(myMsDataFile, origDataFile, combinedParams.DoPrecursorDeconvolution, combinedParams.UseProvidedPrecursorInfo, combinedParams.DeconvolutionIntensityRatio, combinedParams.DeconvolutionMaxAssumedChargeState, combinedParams.DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
for (int currentPartition = 0; currentPartition < CommonParameters.TotalPartitions; currentPartition++)
{
List <CompactPeptide> 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, ionTypes, currentPartition, UsefulProteomicsDatabases.DecoyType.Reverse, ListOfDigestionParams, combinedParams, 30000.0, new List <string> {
taskId
});
List <int>[] fragmentIndex = null;
lock (indexLock)
GenerateIndexes(indexEngine, dbFilenameList, ref peptideIndex, ref fragmentIndex, taskId);
Status("Searching files...", taskId);
new TwoPassCrosslinkSearchEngine(newPsms, arrayOfMs2ScansSortedByMass, peptideIndex, fragmentIndex, ionTypes, currentPartition, combinedParams, false, XlSearchParameters.XlPrecusorMsTl, crosslinker, XlSearchParameters.CrosslinkSearchTop, XlSearchParameters.CrosslinkSearchTopNum, XlSearchParameters.XlQuench_H2O, XlSearchParameters.XlQuench_NH2, XlSearchParameters.XlQuench_Tris, XlSearchParameters.XlCharge_2_3, XlSearchParameters.XlCharge_2_3_PrimeFragment, thisId).Run();
ReportProgress(new ProgressEventArgs(100, "Done with search " + (currentPartition + 1) + "/" + CommonParameters.TotalPartitions + "!", thisId));
}
lock (psmLock)
{
allPsms.AddRange(newPsms.Where(p => p != null));
}
completedFiles++;
ReportProgress(new ProgressEventArgs(completedFiles / currentRawFileList.Count, "Searching...", new List <string> {
taskId, "Individual Spectra Files"
}));
}
ReportProgress(new ProgressEventArgs(100, "Done with all searches!", new List <string> {
taskId, "Individual Spectra Files"
}));
Status("Crosslink analysis engine", taskId);
MetaMorpheusEngineResults allcrosslinkanalysisResults;
allcrosslinkanalysisResults = new CrosslinkAnalysisEngine(allPsms, compactPeptideToProteinPeptideMatch, proteinList, variableModifications, fixedModifications, ionTypes, OutputFolder, crosslinker, terminusType, CommonParameters, new List <string> {
taskId
}).Run();
allPsms = allPsms.ToList();
if (XlSearchParameters.XlOutAll)
{
try
{
WriteAllToTsv(allPsms, OutputFolder, "allPsms", new List <string> {
taskId
});
}
catch (Exception)
{
throw;
}
}
var allPsmsXL = allPsms.Where(p => p.CrossType == PsmCrossType.Cross).Where(p => p.XLBestScore >= CommonParameters.ScoreCutoff && p.BetaPsmCross.XLBestScore >= CommonParameters.ScoreCutoff).ToList();
foreach (var item in allPsmsXL)
{
if (item.OneBasedStartResidueInProtein.HasValue)
{
item.XlProteinPos = item.OneBasedStartResidueInProtein.Value + item.XlPos - 1;
}
if (item.BetaPsmCross.OneBasedStartResidueInProtein.HasValue)
{
item.BetaPsmCross.XlProteinPos = item.BetaPsmCross.OneBasedStartResidueInProtein.Value + item.BetaPsmCross.XlPos - 1;
}
}
//Write Inter Psms FDR
var interPsmsXL = allPsmsXL.Where(p => !p.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First().Contains(p.BetaPsmCross.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First()) &&
!p.BetaPsmCross.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First().Contains(p.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First())).OrderByDescending(p => p.XLQvalueTotalScore).ToList();
foreach (var item in interPsmsXL)
{
item.CrossType = PsmCrossType.Inter;
}
var interPsmsXLFDR = CrosslinkDoFalseDiscoveryRateAnalysis(interPsmsXL).ToList();
//var interPsmsXLFDR = CrosslinkFDRAnalysis(interPsmsXL).ToList();
if (XlSearchParameters.XlOutCrosslink)
{
WriteCrosslinkToTsv(interPsmsXLFDR, OutputFolder, "xl_inter_fdr", new List <string> {
taskId
});
}
if (XlSearchParameters.XlOutPercolator)
{
try
{
var interPsmsXLPercolator = interPsmsXL.Where(p => p.XLBestScore >= 2 && p.BetaPsmCross.XLBestScore >= 2).OrderBy(p => p.ScanNumber).ToList();
WriteCrosslinkToTxtForPercolator(interPsmsXLPercolator, OutputFolder, "xl_inter_perc", crosslinker, new List <string> {
taskId
});
}
catch (Exception)
{
throw;
}
}
//Write Intra Psms FDR
var intraPsmsXL = allPsmsXL.Where(p => p.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First() == p.BetaPsmCross.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First() ||
p.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First().Contains(p.BetaPsmCross.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First()) ||
p.BetaPsmCross.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First().Contains(p.CompactPeptides.First().Value.Item2.Select(b => b.Protein.Accession).First())).OrderByDescending(p => p.XLQvalueTotalScore).ToList();
foreach (var item in intraPsmsXL)
{
item.CrossType = PsmCrossType.Intra;
}
var intraPsmsXLFDR = CrosslinkDoFalseDiscoveryRateAnalysis(intraPsmsXL).ToList();
//var intraPsmsXLFDR = CrosslinkFDRAnalysis(intraPsmsXL).ToList();
if (XlSearchParameters.XlOutCrosslink)
{
WriteCrosslinkToTsv(intraPsmsXLFDR, OutputFolder, "xl_intra_fdr", new List <string> {
taskId
});
}
if (XlSearchParameters.XlOutPercolator)
{
try
{
var intraPsmsXLPercolator = intraPsmsXL.Where(p => p.XLBestScore >= 2 && p.BetaPsmCross.XLBestScore >= 2).OrderBy(p => p.ScanNumber).ToList();
WriteCrosslinkToTxtForPercolator(intraPsmsXLPercolator, OutputFolder, "xl_intra_perc", crosslinker, new List <string> {
taskId
});
}
catch (Exception)
{
throw;
}
}
var singlePsms = allPsms.Where(p => p.CrossType == PsmCrossType.Singe && p.FullSequence != null && !p.FullSequence.Contains("Crosslink")).OrderByDescending(p => p.Score).ToList();
var singlePsmsFDR = SingleFDRAnalysis(singlePsms).ToList();
if (XlSearchParameters.XlOutAll)
{
WriteSingleToTsv(singlePsmsFDR, OutputFolder, "single_fdr", new List <string> {
taskId
});
}
var loopPsms = allPsms.Where(p => p.CrossType == PsmCrossType.Loop).OrderByDescending(p => p.XLTotalScore).ToList();
var loopPsmsFDR = SingleFDRAnalysis(loopPsms).ToList();
if (XlSearchParameters.XlOutAll)
{
WriteSingleToTsv(loopPsmsFDR, OutputFolder, "loop_fdr", new List <string> {
taskId
});
}
var deadendPsms = allPsms.Where(p => p.CrossType == PsmCrossType.DeadEnd || p.CrossType == PsmCrossType.DeadEndH2O || p.CrossType == PsmCrossType.DeadEndNH2 || p.CrossType == PsmCrossType.DeadEndTris).OrderByDescending(p => p.XLTotalScore).ToList();
deadendPsms.AddRange(allPsms.Where(p => p.CrossType == PsmCrossType.Singe && p.FullSequence != null && p.FullSequence.Contains("Crosslink")).ToList());
var deadendPsmsFDR = SingleFDRAnalysis(deadendPsms).ToList();
if (XlSearchParameters.XlOutAll)
{
WriteSingleToTsv(deadendPsmsFDR, OutputFolder, "deadend_fdr", new List <string> {
taskId
});
}
if (XlSearchParameters.XlOutPepXML)
{
List <PsmCross> allPsmsFDR = new List <PsmCross>();
allPsmsFDR.AddRange(intraPsmsXLFDR.Where(p => p.IsDecoy != true && p.BetaPsmCross.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
allPsmsFDR.AddRange(interPsmsXLFDR.Where(p => p.IsDecoy != true && p.BetaPsmCross.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
allPsmsFDR.AddRange(singlePsmsFDR.Where(p => p.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
allPsmsFDR.AddRange(loopPsmsFDR.Where(p => p.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
allPsmsFDR.AddRange(deadendPsmsFDR.Where(p => p.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
allPsmsFDR = allPsmsFDR.OrderBy(p => p.ScanNumber).ToList();
foreach (var fullFilePath in currentRawFileList)
{
string fileNameNoExtension = Path.GetFileNameWithoutExtension(fullFilePath);
WritePepXML_xl(allPsmsFDR.Where(p => p.FullFilePath == fullFilePath).ToList(), proteinList, dbFilenameList[0].FilePath, variableModifications, fixedModifications, localizeableModificationTypes, OutputFolder, fileNameNoExtension, new List <string> {
taskId
});
}
}
if (XlSearchParameters.XlOutAll)
{
List <PsmCross> allPsmsXLFDR = new List <PsmCross>();
allPsmsXLFDR.AddRange(intraPsmsXLFDR.Where(p => p.IsDecoy != true && p.BetaPsmCross.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
allPsmsXLFDR.AddRange(interPsmsXLFDR.Where(p => p.IsDecoy != true && p.BetaPsmCross.IsDecoy != true && p.FdrInfo.QValue <= 0.05).ToList());
try
{
allPsmsXLFDR = allPsmsXLFDR.OrderByDescending(p => p.XLQvalueTotalScore).ToList();
var allPsmsXLFDRGroup = FindCrosslinks(allPsmsXLFDR);
WriteCrosslinkToTsv(allPsmsXLFDRGroup, OutputFolder, "allPsmsXLFDRGroup", new List <string> {
taskId
});
}
catch (Exception)
{
throw;
}
}
return(MyTaskResults);
}
protected override MetaMorpheusEngineResults RunSpecific()
{
double progress = 0;
int oldPercentProgress = 0;
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(ProductTypes);
// digest database
HashSet <CompactPeptide> peptideToId = new HashSet <CompactPeptide>();
Parallel.ForEach(Partitioner.Create(0, ProteinList.Count), new ParallelOptions {
MaxDegreeOfParallelism = commonParameters.MaxThreadsToUsePerFile
}, (range, loopState) =>
{
for (int i = range.Item1; i < range.Item2; i++)
{
// Stop loop if canceled
if (GlobalVariables.StopLoops)
{
loopState.Stop();
return;
}
foreach (var digestionParams in CollectionOfDigestionParams)
{
foreach (var pepWithSetMods in ProteinList[i].Digest(digestionParams, FixedModifications, VariableModifications))
{
CompactPeptide compactPeptide = pepWithSetMods.CompactPeptide(terminusType);
var observed = peptideToId.Contains(compactPeptide);
if (observed)
{
continue;
}
lock (peptideToId)
{
observed = peptideToId.Contains(compactPeptide);
if (observed)
{
continue;
}
peptideToId.Add(compactPeptide);
}
}
}
progress++;
var percentProgress = (int)((progress / ProteinList.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Digesting proteins...", nestedIds));
}
}
});
// sort peptides by mass
var peptidesSortedByMass = peptideToId.AsParallel().WithDegreeOfParallelism(commonParameters.MaxThreadsToUsePerFile).OrderBy(p => p.MonoisotopicMassIncludingFixedMods).ToList();
peptideToId = null;
// create fragment index
List <int>[] fragmentIndex;
try
{
fragmentIndex = new List <int> [(int)Math.Ceiling(MaxFragmentSize) * FragmentBinsPerDalton + 1];
}
catch (OutOfMemoryException)
{
throw new MetaMorpheusException("Max fragment mass too large for indexing engine; try \"Classic Search\" mode, or make the maximum fragment mass smaller");
}
// populate fragment index
progress = 0;
oldPercentProgress = 0;
for (int peptideId = 0; peptideId < peptidesSortedByMass.Count; peptideId++)
{
var validFragments = peptidesSortedByMass[peptideId].ProductMassesMightHaveDuplicatesAndNaNs(ProductTypes).Distinct().Where(p => !Double.IsNaN(p));
foreach (var theoreticalFragmentMass in validFragments)
{
if (theoreticalFragmentMass < MaxFragmentSize && theoreticalFragmentMass > 0)
{
int fragmentBin = (int)Math.Round(theoreticalFragmentMass * FragmentBinsPerDalton);
if (fragmentIndex[fragmentBin] == null)
{
fragmentIndex[fragmentBin] = new List <int> {
peptideId
}
}
;
else
{
fragmentIndex[fragmentBin].Add(peptideId);
}
}
}
progress++;
var percentProgress = (int)((progress / peptidesSortedByMass.Count) * 100);
if (percentProgress > oldPercentProgress)
{
oldPercentProgress = percentProgress;
ReportProgress(new ProgressEventArgs(percentProgress, "Creating fragment index...", nestedIds));
}
}
return(new IndexingResults(peptidesSortedByMass, fragmentIndex, this));
}
protected override MetaMorpheusEngineResults RunSpecific()
{
double progress = 0;
int oldPercentProgress = 0;
ReportProgress(new ProgressEventArgs(oldPercentProgress, "Performing nonspecific search... " + CurrentPartition + "/" + commonParameters.TotalPartitions, nestedIds));
TerminusType terminusType = ProductTypeMethods.IdentifyTerminusType(ProductTypes);
byte byteScoreCutoff = (byte)commonParameters.ScoreCutoff;
Parallel.ForEach(Partitioner.Create(0, ListOfSortedms2Scans.Length), new ParallelOptions {
MaxDegreeOfParallelism = commonParameters.MaxThreadsToUsePerFile
}, range =>
{
byte[] scoringTable = new byte[PeptideIndex.Count];
HashSet <int> idsOfPeptidesPossiblyObserved = new HashSet <int>();
for (int i = range.Item1; i < range.Item2; i++)
{
// 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[i];
//get bins to add points to
List <int> allBinsToSearch = GetBinsToSearch(scan);
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 <int> binsToSearch = new List <int>();
int obsPrecursorFloorMz = (int)Math.Floor(commonParameters.PrecursorMassTolerance.GetMinimumValue(scan.PrecursorMass) * FragmentBinsPerDalton);
int obsPrecursorCeilingMz = (int)Math.Ceiling(commonParameters.PrecursorMassTolerance.GetMaximumValue(scan.PrecursorMass) * FragmentBinsPerDalton);
for (int fragmentBin = obsPrecursorFloorMz; fragmentBin <= obsPrecursorCeilingMz; fragmentBin++)
{
binsToSearch.Add(fragmentBin);
}
foreach (ProductType pt in ProductTypes)
{
int binShift;
switch (pt)
{
case ProductType.B:
binShift = bBinShift;
break;
case ProductType.Y:
binShift = 0;
break;
case ProductType.C:
binShift = cBinShift;
break;
case ProductType.Zdot:
binShift = zdotBinShift;
break;
default:
throw new NotImplementedException();
}
for (int j = 0; j < binsToSearch.Count; j++)
{
int bin = binsToSearch[j] - binShift;
if (bin < FragmentIndex.Length && FragmentIndex[bin] != null)
{
FragmentIndex[bin].ForEach(id => idsOfPeptidesPossiblyObserved.Add(id));
}
}
}
for (int j = 0; j < binsToSearch.Count; j++)
{
int bin = binsToSearch[j];
if (bin < fragmentIndexPrecursor.Length && fragmentIndexPrecursor[bin] != null)
{
fragmentIndexPrecursor[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)
{
maxInitialScore--;
foreach (var id in idsOfPeptidesPossiblyObserved.Where(id => scoringTable[id] == maxInitialScore))
{
var candidatePeptide = PeptideIndex[id];
double[] fragmentMasses = candidatePeptide.ProductMassesMightHaveDuplicatesAndNaNs(ProductTypes).Distinct().Where(p => !Double.IsNaN(p)).OrderBy(p => p).ToArray();
double peptideScore = CalculatePeptideScoreOld(scan.TheScan, commonParameters.ProductMassTolerance, fragmentMasses, scan.PrecursorMass, DissociationTypes, commonParameters.AddCompIons, MaxMassThatFragmentIonScoreIsDoubled);
Tuple <int, double> notchAndPrecursor = Accepts(scan.PrecursorMass, candidatePeptide, terminusType, MassDiffAcceptor);
if (notchAndPrecursor.Item1 >= 0)
{
CompactPeptideWithModifiedMass cp = new CompactPeptideWithModifiedMass(candidatePeptide, notchAndPrecursor.Item2);
if (PeptideSpectralMatches[i] == null)
{
PeptideSpectralMatches[i] = new PeptideSpectralMatch(cp, notchAndPrecursor.Item1, peptideScore, i, scan, commonParameters.DigestionParams);
}
else
{
PeptideSpectralMatches[i].AddOrReplace(cp, peptideScore, notchAndPrecursor.Item1, commonParameters.ReportAllAmbiguity);
}
}
}
if (PeptideSpectralMatches[i] != null)
{
break;
}
}
}
// report search progress
progress++;
var 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 MyTaskResults RunSpecific(string OutputFolder, List <DbForTask> dbFilenameList, List <string> currentRawFileList, string taskId, FileSpecificParameters[] fileSettingsList)
{
// disable quantification if a .mgf is being used
if (SearchParameters.DoQuantification && currentRawFileList.Any(x => Path.GetExtension(x).Equals(".mgf", StringComparison.OrdinalIgnoreCase)))
{
SearchParameters.DoQuantification = false;
}
// load modifications
Status("Loading modifications...", taskId);
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();
List <string> localizeableModificationTypes = GlobalVariables.AllModTypesKnown.ToList();
// what types of fragment ions to search for
List <ProductType> ionTypes = new List <ProductType>();
if (CommonParameters.BIons && CommonParameters.AddCompIons)
{
ionTypes.Add(ProductType.B);
}
else if (CommonParameters.BIons)
{
ionTypes.Add(ProductType.BnoB1ions);
}
if (CommonParameters.YIons)
{
ionTypes.Add(ProductType.Y);
}
if (CommonParameters.ZdotIons)
{
ionTypes.Add(ProductType.Zdot);
}
if (CommonParameters.CIons)
{
ionTypes.Add(ProductType.C);
}
// load proteins
List <Protein> proteinList = LoadProteins(taskId, dbFilenameList, SearchParameters.SearchTarget, SearchParameters.DecoyType, localizeableModificationTypes, CommonParameters);
// 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.id)) + "; ");
ProseCreatedWhileRunning.Append("variable modifications = " + string.Join(", ", variableModifications.Select(m => m.id)) + "; ");
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>();
FlashLFQResults flashLfqResults = null;
MyFileManager myFileManager = new MyFileManager(SearchParameters.DisposeOfFileWhenDone);
var fileSpecificCommonParams = fileSettingsList.Select(b => SetAllFileSpecificCommonParams(CommonParameters, b));
HashSet <DigestionParams> ListOfDigestionParams = new HashSet <DigestionParams>(fileSpecificCommonParams.Select(p => p.DigestionParams));
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.TopNpeaks, combinedParams.MinRatio, combinedParams.TrimMs1Peaks, combinedParams.TrimMsMsPeaks, combinedParams);
Status("Getting ms2 scans...", thisId);
Ms2ScanWithSpecificMass[] arrayOfMs2ScansSortedByMass = GetMs2Scans(myMsDataFile, origDataFile, combinedParams.DoPrecursorDeconvolution, combinedParams.UseProvidedPrecursorInfo, combinedParams.DeconvolutionIntensityRatio, combinedParams.DeconvolutionMaxAssumedChargeState, combinedParams.DeconvolutionMassTolerance).OrderBy(b => b.PrecursorMass).ToArray();
numMs2SpectraPerFile.Add(Path.GetFileNameWithoutExtension(origDataFile), new int[] { myMsDataFile.GetAllScansList().Count(p => p.MsnOrder == 2), arrayOfMs2ScansSortedByMass.Length });
myFileManager.DoneWithFile(origDataFile);
var fileSpecificPsms = new PeptideSpectralMatch[arrayOfMs2ScansSortedByMass.Length];
// modern search
if (SearchParameters.SearchType == SearchType.Modern)
{
for (int currentPartition = 0; currentPartition < combinedParams.TotalPartitions; currentPartition++)
{
List <CompactPeptide> 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, ionTypes, currentPartition, SearchParameters.DecoyType, ListOfDigestionParams, combinedParams, SearchParameters.MaxFragmentSize, new List <string> {
taskId
});
List <int>[] fragmentIndex = null;
lock (indexLock)
{
GenerateIndexes(indexEngine, dbFilenameList, ref peptideIndex, ref fragmentIndex, taskId);
}
Status("Searching files...", taskId);
new ModernSearchEngine(fileSpecificPsms, arrayOfMs2ScansSortedByMass, peptideIndex, fragmentIndex, ionTypes, currentPartition, combinedParams, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, thisId).Run();
ReportProgress(new ProgressEventArgs(100, "Done with search " + (currentPartition + 1) + "/" + combinedParams.TotalPartitions + "!", thisId));
}
}
// nonspecific search
else if (SearchParameters.SearchType == SearchType.NonSpecific)
{
List <List <ProductType> > terminusSeparatedIons = ProductTypeMethods.SeparateIonsByTerminus(ionTypes);
foreach (List <ProductType> terminusSpecificIons in terminusSeparatedIons)
{
for (int currentPartition = 0; currentPartition < combinedParams.TotalPartitions; currentPartition++)
{
List <CompactPeptide> peptideIndex = null;
List <Protein> proteinListSubset = proteinList.GetRange(currentPartition * proteinList.Count() / combinedParams.TotalPartitions, ((currentPartition + 1) * proteinList.Count() / combinedParams.TotalPartitions) - (currentPartition * proteinList.Count() / combinedParams.TotalPartitions));
List <int>[] fragmentIndex = new List <int> [1];
Status("Getting fragment dictionary...", new List <string> {
taskId
});
var indexEngine = new IndexingEngine(proteinListSubset, variableModifications, fixedModifications, terminusSpecificIons, currentPartition, SearchParameters.DecoyType, ListOfDigestionParams, combinedParams, SearchParameters.MaxFragmentSize, new List <string> {
taskId
});
lock (indexLock)
GenerateIndexes(indexEngine, dbFilenameList, ref peptideIndex, ref fragmentIndex, taskId);
Status("Getting precursor dictionary...", new List <string> {
taskId
});
List <CompactPeptide> peptideIndexPrecursor = null;
List <Protein> proteinListSubsetPrecursor = proteinList.GetRange(currentPartition * proteinList.Count() / combinedParams.TotalPartitions, ((currentPartition + 1) * proteinList.Count() / combinedParams.TotalPartitions) - (currentPartition * proteinList.Count() / combinedParams.TotalPartitions));
List <int>[] fragmentIndexPrecursor = new List <int> [1];
var indexEnginePrecursor = new PrecursorIndexingEngine(proteinListSubsetPrecursor, variableModifications, fixedModifications, terminusSpecificIons, currentPartition, SearchParameters.DecoyType, ListOfDigestionParams, combinedParams, 0, new List <string> {
taskId
});
lock (indexLock)
GenerateIndexes(indexEnginePrecursor, dbFilenameList, ref peptideIndexPrecursor, ref fragmentIndexPrecursor, taskId);
if (peptideIndex.Count != peptideIndexPrecursor.Count)
{
throw new MetaMorpheusException("peptideIndex not identical between indexing engines");
}
Status("Searching files...", taskId);
new NonSpecificEnzymeSearchEngine(fileSpecificPsms, arrayOfMs2ScansSortedByMass, peptideIndex, fragmentIndex, fragmentIndexPrecursor, terminusSpecificIons, currentPartition, combinedParams, massDiffAcceptor, SearchParameters.MaximumMassThatFragmentIonScoreIsDoubled, thisId).Run();
ReportProgress(new ProgressEventArgs(100, "Done with search " + (currentPartition + 1) + "/" + combinedParams.TotalPartitions + "!", thisId));
}
}
}
// classic search
else
{
Status("Starting search...", thisId);
new ClassicSearchEngine(fileSpecificPsms, arrayOfMs2ScansSortedByMass, variableModifications, fixedModifications, proteinList, ionTypes, massDiffAcceptor, combinedParams, thisId).Run();
ReportProgress(new ProgressEventArgs(100, "Done with search!", thisId));
}
lock (psmLock)
{
allPsms.AddRange(fileSpecificPsms.Where(p => p != null));
}
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"
}));
}
ReportProgress(new ProgressEventArgs(100, "Done with all searches!", new List <string> {
taskId, "Individual Spectra Files"
}));
PostSearchAnalysisParameters parameters = new PostSearchAnalysisParameters();
parameters.SearchTaskResults = MyTaskResults;
parameters.SearchTaskId = taskId;
parameters.SearchParameters = SearchParameters;
parameters.ProteinList = proteinList;
parameters.IonTypes = ionTypes;
parameters.AllPsms = allPsms;
parameters.FixedModifications = fixedModifications;
parameters.VariableModifications = variableModifications;
parameters.ListOfDigestionParams = ListOfDigestionParams;
parameters.CurrentRawFileList = currentRawFileList;
parameters.MyFileManager = myFileManager;
parameters.NumNotches = GetNumNotches(SearchParameters.MassDiffAcceptorType, SearchParameters.CustomMdac);
parameters.OutputFolder = OutputFolder;
parameters.IndividualResultsOutputFolder = Path.Combine(OutputFolder, "Individual File Results");
parameters.FlashLfqResults = flashLfqResults;
parameters.FileSettingsList = fileSettingsList;
parameters.NumMs2SpectraPerFile = numMs2SpectraPerFile;
parameters.DatabaseFilenameList = dbFilenameList;
PostSearchAnalysisTask postProcessing = new PostSearchAnalysisTask();
postProcessing.Parameters = parameters;
postProcessing.CommonParameters = CommonParameters;
return(postProcessing.Run());
}
