public void MergeResultsWith(FlashLfqResults mergeFrom) { this.SpectraFiles.AddRange(mergeFrom.SpectraFiles); foreach (var pep in mergeFrom.PeptideModifiedSequences) { if (this.PeptideModifiedSequences.TryGetValue(pep.Key, out var peptide)) { Peptide mergeFromPep = pep.Value; Peptide mergeToPep = peptide; foreach (SpectraFileInfo file in mergeFrom.SpectraFiles) { mergeToPep.SetIntensity(file, mergeFromPep.GetIntensity(file)); mergeToPep.SetDetectionType(file, mergeFromPep.GetDetectionType(file)); } } else { this.PeptideModifiedSequences.Add(pep.Key, pep.Value); } } foreach (var pg in mergeFrom.ProteinGroups) { if (this.ProteinGroups.TryGetValue(pg.Key, out var proteinGroup)) { ProteinGroup mergeFromPg = pg.Value; ProteinGroup mergeToPg = proteinGroup; foreach (SpectraFileInfo file in mergeFrom.SpectraFiles) { mergeToPg.SetIntensity(file, mergeFromPg.GetIntensity(file)); } } else { this.ProteinGroups.Add(pg.Key, pg.Value); } } foreach (var fromPeaks in mergeFrom.Peaks) { if (this.Peaks.TryGetValue(fromPeaks.Key, out var toPeaks)) { toPeaks.AddRange(fromPeaks.Value); } else { this.Peaks.Add(fromPeaks.Key, fromPeaks.Value); } } }
//If SILAC (Post-Quantification), compress the light/heavy protein group pairs into the same light protein group but different files //Create new files for each silac label and file so that "file 1" now becomes "file 1 (light)" and "file 1 (heavy)" //Change heavy residue into the light residue plus a string label ("PEPTIDEa" -> "PEPTIDEK(+8.014)") //This light to heavy conversion needs to happen for the flashLFQ peptides here, but can't for the psm peptides, which are constrained to the protein //i.e. pwsms currently don't have sequences; they have start/end residues and a protein sequence. We have to change the output sequences when they're created. public static void SilacConversionsPostQuantification(List <SilacLabel> allSilacLabels, SilacLabel startLabel, SilacLabel endLabel, List <SpectraFileInfo> spectraFileInfo, List <ProteinGroup> proteinGroups, HashSet <DigestionParams> listOfDigestionParams, FlashLfqResults flashLfqResults, List <PeptideSpectralMatch> allPsms, Dictionary <string, int> modsToWriteSelection, bool quantifyUnlabeledPeptides) { //do protein quant if we had any results //if no results, we still may need to edit the psms if (flashLfqResults != null) //can be null if no unambiguous psms were found { //after this point, we now have quantification values for the peptides, but they all belong to the same "unlabeled" protein and are in the same file //We can remove "labeled" peptides from each file and put them in a new file as "unlabeled". //MAKE NEW RAW FILES //update number of spectra files to include a new file for each label/condition Dictionary <SpectraFileInfo, List <SpectraFileInfo> > originalToLabeledFileInfoDictionary = CreateSilacRawFiles(flashLfqResults, allSilacLabels, startLabel, endLabel, quantifyUnlabeledPeptides, spectraFileInfo); //we have the files, now let's reassign the psms. //there are a few ways to do this, but we're going to generate the "base" peptide and assign to that //Get Dictionary of protein accessions to peptides Dictionary <string, List <FlashLFQ.Peptide> > unlabeledToPeptidesDictionary = GetDictionaryOfProteinAccessionsToPeptides(flashLfqResults.PeptideModifiedSequences.Values, allSilacLabels, startLabel, endLabel); //we now have a dictionary of unlabeledBaseSequence to the labeled peptides //Better SILAC results can be obtained by using the summed intensities from ms1 scans where all peaks were found, rather than the apex //foreach peptide, unlabeled peptide, get the isotopic envelope intensities for each labeled peptide in each file //save the intensities from ms1s that are shared. If no ms1s contains all the peaks, then just use the apex intensity (default) CalculateSilacIntensities(flashLfqResults.Peaks, unlabeledToPeptidesDictionary); //SPLIT THE FILES List <FlashLFQ.Peptide> updatedPeptides = new List <FlashLFQ.Peptide>(); //split the heavy/light peptides into separate raw files, remove the heavy peptide if (startLabel != null || endLabel != null) //if turnover { //foreach group, the labeled peptides should be split into their labeled files //we're deleting the heavy results after we pull those results into a different file foreach (SpectraFileInfo info in spectraFileInfo) { string fullPathWithExtension = info.FullFilePathWithExtension; string[] pathArray = fullPathWithExtension.Split('.'); string extension = pathArray.Last(); string filePathWithoutExtension = fullPathWithExtension.Substring(0, fullPathWithExtension.Length - extension.Length - 1); //-1 removes the '.' SpectraFileInfo lightInfo = new SpectraFileInfo(filePathWithoutExtension + "_Original." + extension, info.Condition, info.BiologicalReplicate, info.TechnicalReplicate, info.Fraction); SpectraFileInfo heavyInfo = new SpectraFileInfo(filePathWithoutExtension + "_NewlySynthesized." + extension, info.Condition + "_NewlySynthesized", info.BiologicalReplicate, info.TechnicalReplicate, info.Fraction); originalToLabeledFileInfoDictionary[info] = new List <SpectraFileInfo> { lightInfo, heavyInfo }; flashLfqResults.SpectraFiles.Add(lightInfo); flashLfqResults.SpectraFiles.Add(heavyInfo); } //This step converts the quantification intensities from light/heavy to original/newlySynthesized by splitting up the missed cleavage mixtures foreach (KeyValuePair <string, List <FlashLFQ.Peptide> > kvp in unlabeledToPeptidesDictionary) { string unlabeledSequence = kvp.Key; //this will be the key for the new quant entry List <FlashLFQ.Peptide> peptides = kvp.Value; if (peptides.Count != 1) //sometimes it's one if there is no label site on the peptide (e.g. label K, peptide is PEPTIDER) { //Missed cleavages can yield multiple peptides (e.g. 1 missed = LL, LH, HH; 2 missed = LLL, LLH, LHH, HHH; etc) //Compress into 2 values: Light and Heavy FlashLFQ.Peptide updatedPeptide = new FlashLFQ.Peptide(unlabeledSequence, unlabeledSequence, peptides[0].UseForProteinQuant, CleanPastProteinQuant(peptides[0].ProteinGroups)); //needed to keep protein info. foreach (SpectraFileInfo info in spectraFileInfo) { int maxNumberHeavyAminoAcids = peptides.Count - 1; double lightIntensity = 0; double heavyIntensity = 0; int numUniquePeptidesQuantified = 0; for (int numHeavyAminoAcids = 0; numHeavyAminoAcids < peptides.Count; numHeavyAminoAcids++) { double totalIntensity = peptides[numHeavyAminoAcids].GetIntensity(info); if (totalIntensity > 0) { //prevent confidence of a ratio if only the HL (and not the LL or HH) is observed. //If LL or HH is observed (but not any other), the user knows the ratio is only from one peak. if (numHeavyAminoAcids == 0 || numHeavyAminoAcids == maxNumberHeavyAminoAcids) { numUniquePeptidesQuantified += 2; } else { numUniquePeptidesQuantified++; } double partHeavyIntensity = totalIntensity * numHeavyAminoAcids / maxNumberHeavyAminoAcids; lightIntensity += totalIntensity - partHeavyIntensity; heavyIntensity += partHeavyIntensity; } } //If only a mixed peptide with a missed cleavage was identified, reset the intensity values to zero so the user doesn't get a discreet, inaccurate measurement if (numUniquePeptidesQuantified < 2) { lightIntensity = 0; heavyIntensity = 0; } List <SpectraFileInfo> updatedInfo = originalToLabeledFileInfoDictionary[info]; SpectraFileInfo startInfo = updatedInfo[0]; SpectraFileInfo endInfo = updatedInfo[1]; updatedPeptide.SetIntensity(startInfo, lightIntensity); //assign the corrected light intensity updatedPeptide.SetDetectionType(startInfo, peptides.First().GetDetectionType(info)); updatedPeptide.SetIntensity(endInfo, heavyIntensity); //assign the corrected heavy intensity to the heavy file updatedPeptide.SetDetectionType(endInfo, peptides.Last().GetDetectionType(info)); //could include the mixed here if it really matters } //add the updated peptide to the list updatedPeptides.Add(updatedPeptide); } else { updatedPeptides.Add(peptides[0]); } } } else //multiplex { foreach (var kvp in unlabeledToPeptidesDictionary) { string unlabeledSequence = kvp.Key; List <FlashLFQ.Peptide> peptides = kvp.Value; FlashLFQ.Peptide representativePeptide = peptides[0]; FlashLFQ.Peptide updatedPeptide = new FlashLFQ.Peptide(unlabeledSequence, unlabeledSequence, representativePeptide.UseForProteinQuant, CleanPastProteinQuant(representativePeptide.ProteinGroups)); //needed to keep protein info. //foreach original file foreach (SpectraFileInfo info in spectraFileInfo) { List <SpectraFileInfo> filesForThisFile = originalToLabeledFileInfoDictionary[info]; for (int i = 0; i < peptides.Count; i++) //the files and the peptides can use the same index, because there should be a distinct file for each label/peptide { SpectraFileInfo currentInfo = filesForThisFile[i]; FlashLFQ.Peptide currentPeptide = peptides[i]; updatedPeptide.SetIntensity(currentInfo, currentPeptide.GetIntensity(info)); updatedPeptide.SetDetectionType(currentInfo, currentPeptide.GetDetectionType(info)); } } updatedPeptides.Add(updatedPeptide); } } //Update peptides var peptideResults = flashLfqResults.PeptideModifiedSequences; peptideResults.Clear(); foreach (FlashLFQ.Peptide peptide in updatedPeptides) { peptideResults.Add(peptide.Sequence, peptide); } //Do protein quant flashLfqResults.CalculateProteinResultsMedianPolish(true); //update proteingroups to have all files for quantification if (proteinGroups != null) { List <SpectraFileInfo> allInfo = originalToLabeledFileInfoDictionary.SelectMany(x => x.Value).ToList(); foreach (ProteinGroup proteinGroup in proteinGroups) { proteinGroup.FilesForQuantification = allInfo; proteinGroup.IntensitiesByFile = new Dictionary <SpectraFileInfo, double>(); foreach (var spectraFile in allInfo) { if (flashLfqResults.ProteinGroups.TryGetValue(proteinGroup.ProteinGroupName, out var flashLfqProteinGroup)) { proteinGroup.IntensitiesByFile.Add(spectraFile, flashLfqProteinGroup.GetIntensity(spectraFile)); } else { //needed for decoys/contaminants/proteins that aren't quantified proteinGroup.IntensitiesByFile.Add(spectraFile, 0); } } } } //Convert all lfqpeaks from heavy (a) to light (K+8.014) for output if (flashLfqResults != null) //can be null if nothing was quantified (all peptides are ambiguous) { var lfqPeaks = flashLfqResults.Peaks; List <SpectraFileInfo> peakKeys = lfqPeaks.Keys.ToList(); foreach (SpectraFileInfo key in peakKeys) { List <ChromatographicPeak> peaks = lfqPeaks[key]; for (int i = 0; i < peaks.Count; i++) { var peak = peaks[i]; //check if we're removing light peaks and if it's a light peak if (peak.Identifications.Any(x => GetRelevantLabelFromBaseSequence(x.BaseSequence, allSilacLabels) != null)) //if no ids have any labels, remove them { List <Identification> updatedIds = new List <Identification>(); foreach (var id in peak.Identifications) { string baseSequence = id.BaseSequence; string fullSequence = id.ModifiedSequence; List <SilacLabel> labels = GetRelevantLabelsFromBaseSequenceForOutput(id.BaseSequence, allSilacLabels); if (labels != null) { foreach (SilacLabel label in labels) { baseSequence = GetSilacLightBaseSequence(baseSequence, label); fullSequence = GetSilacLightFullSequence(fullSequence, label); } } Identification updatedId = new Identification( id.FileInfo, baseSequence, fullSequence, id.MonoisotopicMass, id.Ms2RetentionTimeInMinutes, id.PrecursorChargeState, id.ProteinGroups.ToList(), id.OptionalChemicalFormula, id.UseForProteinQuant ); updatedIds.Add(updatedId); } peak.Identifications.Clear(); peak.Identifications.AddRange(updatedIds); } } } } } //convert all psms into human readable format for (int i = 0; i < allPsms.Count; i++) { allPsms[i].ResolveHeavySilacLabel(allSilacLabels, modsToWriteSelection); } }
//If SILAC (Post-Quantification), compress the light/heavy protein group pairs into the same light protein group but different files //Create new files for each silac label and file so that "file 1" now becomes "file 1 (light)" and "file 1 (heavy)" //Change heavy residue into the light residue plus a string label ("PEPTIDEa" -> "PEPTIDEK(+8.014)") //This light to heavy conversion needs to happen for the flashLFQ peptides here, but can't for the psm peptides, which are constrained to the protein //i.e. pwsms currently don't have sequences; they have start/end residues and a protein sequence. We have to change the output sequences when they're created. public static void SilacConversionsPostQuantification(List <SilacLabel> silacLabels, List <SpectraFileInfo> spectraFileInfo, List <ProteinGroup> ProteinGroups, HashSet <DigestionParams> ListOfDigestionParams, Dictionary <string, List <string> > silacProteinGroupMatcher, FlashLfqResults FlashLfqResults, List <PeptideSpectralMatch> allPsms, Dictionary <string, int> ModsToWriteSelection, bool Integrate) { bool outputLightIntensities = ListOfDigestionParams.Any(x => x.GeneratehUnlabeledProteinsForSilac); //MAKE NEW RAW FILES //update number of spectra files to include a new file for each label*condition Dictionary <SpectraFileInfo, string> fileToLabelDictionary = new Dictionary <SpectraFileInfo, string>(); //figure out which file is which label, since some files will be only light and others only heavy. Key is file, value is the label string (label.MassDifference) Dictionary <SpectraFileInfo, SpectraFileInfo> labeledToUnlabeledFile = new Dictionary <SpectraFileInfo, SpectraFileInfo>(); //keep track of the heavy-to-light pairs. If multiple, looks like 3-1 and 2-1, but no 3-2 (only heavy to light, no heavy to heavy) List <SpectraFileInfo> silacSpectraFileInfo = new List <SpectraFileInfo>(); //new files //foreach existing file foreach (SpectraFileInfo originalFile in spectraFileInfo) { //add the existing file as the light silacSpectraFileInfo.Add(originalFile); //foreach label, add a new file with the label foreach (SilacLabel label in silacLabels) { SpectraFileInfo silacFile = GetHeavyFileInfo(originalFile, label); silacSpectraFileInfo.Add(silacFile); fileToLabelDictionary[silacFile] = label.MassDifference; labeledToUnlabeledFile[silacFile] = originalFile; } } //UPDATE PROTEIN GROUPS //remove the heavy protein groups so that there are only light ones //add the intensities of the heavy groups into the newly created heavy SpectraFileInfos HashSet <SpectraFileInfo> lightFilesToRemove = new HashSet <SpectraFileInfo>(); //this is only used when there user specified no unlabeled proteins if (ProteinGroups != null) //if we did parsimony { List <EngineLayer.ProteinGroup> silacProteinGroups = new List <EngineLayer.ProteinGroup>(); //The light/unlabeled peptides/proteins were not searched if specified, but they were still quantified to keep track of the labels //we need to remove these unlabeled peptides/proteins before output //foreach protein group (which has its own quant for each file) foreach (EngineLayer.ProteinGroup proteinGroup in ProteinGroups) { proteinGroup.FilesForQuantification = silacSpectraFileInfo; //update fileinfo for the group //grab the light groups. Using these light groups, find their heavy group pair(s), add them to the light group quant info, and then remove the heavy groups if (silacProteinGroupMatcher.TryGetValue(proteinGroup.ProteinGroupName, out List <string> silacSubGroupNames)) //try to find the light protein groups. If it's not light, ignore it { //the out variable contains all the other heavy protein groups that were generated for this light protein group //go through the files and see if any of them contain the same label. If not, put zeroes for those missing "files" //If the user didn't specify to search light intensities, then don't output them Dictionary <SpectraFileInfo, double> updatedIntensitiesByFile = proteinGroup.IntensitiesByFile; //light intensities List <SpectraFileInfo> lightKeys = updatedIntensitiesByFile.Keys.ToList(); //go through all files (including "silac" files) List <ProteinGroup> subGroup = ProteinGroups.Where(x => silacSubGroupNames.Contains(x.ProteinGroupName)).ToList(); //find the protein groups where the accession contains "light" accession of the current protein group foreach (SpectraFileInfo fileInfo in silacSpectraFileInfo) //for every file (light and heavy) { //if it doesn't have a value, then it's a silac file (light missing values still have a value "0") if (!updatedIntensitiesByFile.ContainsKey(fileInfo)) { string labelSignature = fileToLabelDictionary[fileInfo]; //a string associated with a silac label ProteinGroup foundGroup = subGroup.Where(x => x.Proteins.Any(y => y.Accession.Contains(labelSignature))).FirstOrDefault(); //get the protein groups containing this label updatedIntensitiesByFile[fileInfo] = foundGroup == null ? 0 : foundGroup.IntensitiesByFile[labeledToUnlabeledFile[fileInfo]]; //update the intensity for that label in the light group } //else do nothing. The light version is already in the dictionary } //The light/unlabeled peptides/proteins were not searched if specified, but they were still quantified to keep track of the labels //we need to remove these unlabeled peptides/proteins before output if (!outputLightIntensities) { foreach (SpectraFileInfo info in lightKeys) { updatedIntensitiesByFile.Remove(info); proteinGroup.FilesForQuantification.Remove(info); lightFilesToRemove.Add(info); } } silacProteinGroups.Add(proteinGroup); } } //update ProteinGroups.Clear(); ProteinGroups.AddRange(silacProteinGroups); //remove light files (if necessary) foreach (SpectraFileInfo info in lightFilesToRemove) { FlashLfqResults.SpectraFiles.Remove(info); } //UPDATE FLASHLFQ PROTEINS if (FlashLfqResults != null) //can be null if nothing was quantified (all peptides are ambiguous) { Dictionary <string, FlashLFQ.ProteinGroup> flashLfqProteins = FlashLfqResults.ProteinGroups; //dictionary of protein group names to protein groups //if the protein group is a heavy protein group, get rid of it. We already accounted for it above. var keys = flashLfqProteins.Keys.ToList(); foreach (string key in keys) { if (silacLabels.Any(x => key.Contains(x.MassDifference))) { flashLfqProteins.Remove(key); } } } } ////UPDATE FLASHLFQ SPECTRA FILES if (FlashLfqResults != null) //can be null if nothing was quantified (all peptides are ambiguous) { List <SpectraFileInfo> originalFiles = FlashLfqResults.SpectraFiles; //pass reference foreach (SpectraFileInfo info in silacSpectraFileInfo) { if (!originalFiles.Contains(info)) { originalFiles.Add(info); } } } //UPDATE PEPTIDE INFO //convert all psm/peptide/proteingroup sequences from the heavy label to the light label for output //We can do this for all of the FlashLFQ peptides/peaks, because they use string sequences. //We are unable to do this for Parameters.AllPsms, because they store proteins and start/end residues instead //for Psms, we need to convert during the writing. for (int i = 0; i < allPsms.Count; i++) { allPsms[i].ResolveHeavySilacLabel(silacLabels, ModsToWriteSelection); } //Convert all lfqpeaks from heavy (a) to light (K+8.014) for output if (FlashLfqResults != null) //can be null if nothing was quantified (all peptides are ambiguous) { var lfqPeaks = FlashLfqResults.Peaks; List <SpectraFileInfo> peakKeys = lfqPeaks.Keys.ToList(); foreach (SpectraFileInfo key in peakKeys) { List <FlashLFQ.ChromatographicPeak> peaks = lfqPeaks[key]; for (int i = 0; i < peaks.Count; i++) { var peak = peaks[i]; List <Identification> identifications = new List <Identification>(); //check if we're removing light peaks and if it's a light peak if (!outputLightIntensities && !peak.Identifications.Any(x => GetRelevantLabelFromBaseSequence(x.BaseSequence, silacLabels) != null)) //if no ids have any labels, remove them { peaks.RemoveAt(i); i--; } else { foreach (var id in peak.Identifications) { SilacLabel label = GetRelevantLabelFromBaseSequence(id.BaseSequence, silacLabels); HashSet <FlashLFQ.ProteinGroup> originalGroups = id.proteinGroups; List <FlashLFQ.ProteinGroup> updatedGroups = new List <FlashLFQ.ProteinGroup>(); foreach (FlashLFQ.ProteinGroup group in originalGroups) { string groupName = group.ProteinGroupName; if (label == null) //if light { updatedGroups.Add(group); } else { string labelString = "(" + label.OriginalAminoAcid + label.MassDifference; int labelIndex = groupName.IndexOf(labelString); if (labelIndex != -1) //labelIndex == 1 if a) 2+ peptides are required per protein or b) somebody broke parsimony { groupName = groupName.Substring(0, labelIndex); updatedGroups.Add(new FlashLFQ.ProteinGroup(groupName, group.GeneName, group.Organism)); } } } Identification updatedId = new Identification( id.fileInfo, GetSilacLightBaseSequence(id.BaseSequence, label), GetSilacLightFullSequence(id.ModifiedSequence, label), id.monoisotopicMass, id.ms2RetentionTimeInMinutes, id.precursorChargeState, updatedGroups, id.OptionalChemicalFormula, id.UseForProteinQuant ); identifications.Add(updatedId); } FlashLFQ.ChromatographicPeak updatedPeak = new FlashLFQ.ChromatographicPeak(identifications.First(), peak.IsMbrPeak, peak.SpectraFileInfo); for (int j = 1; j < identifications.Count; j++) //add all the original identification { updatedPeak.MergeFeatureWith(new FlashLFQ.ChromatographicPeak(identifications[j], peak.IsMbrPeak, peak.SpectraFileInfo), Integrate); } updatedPeak.IsotopicEnvelopes = peak.IsotopicEnvelopes; //need to set isotopicEnevelopes, since the new identifications didn't have them. updatedPeak.CalculateIntensityForThisFeature(Integrate); //needed to update info peaks[i] = updatedPeak; } } } //convert all lfq peptides from heavy to light for output Dictionary <string, FlashLFQ.Peptide> lfqPwsms = FlashLfqResults.PeptideModifiedSequences; List <string> pwsmKeys = lfqPwsms.Keys.ToList(); foreach (string key in pwsmKeys) { FlashLFQ.Peptide currentPeptide = lfqPwsms[key]; SilacLabel label = GetRelevantLabelFromFullSequence(currentPeptide.Sequence, silacLabels); if (label != null) //if it's a heavy peptide { lfqPwsms.Remove(key); //get rid of it //update the light version string lightSequence = GetSilacLightFullSequence(currentPeptide.Sequence, label, false); //get the light sequence List <SpectraFileInfo> heavyFiles = silacSpectraFileInfo.Where(x => x.FilenameWithoutExtension.Contains(label.MassDifference)).ToList(); //these are the heavy raw file names //Find the light peptide (which has a value for the light datafile) and set the intensity for the heavy datafile from the current peptide if (lfqPwsms.TryGetValue(lightSequence, out FlashLFQ.Peptide lightPeptide)) //this should always have a value, since we made replicas earlier, and yet it sometimes doesn't... { foreach (SpectraFileInfo heavyFile in heavyFiles) { SpectraFileInfo lightFile = labeledToUnlabeledFile[heavyFile]; lightPeptide.SetIntensity(heavyFile, currentPeptide.GetIntensity(lightFile)); lightPeptide.SetDetectionType(heavyFile, currentPeptide.GetDetectionType(lightFile)); } } else //if there's no light, create a new entry for the heavy { //new peptide FlashLFQ.Peptide updatedPeptide = new FlashLFQ.Peptide(lightSequence, currentPeptide.UseForProteinQuant); //update the heavy info, set the light values to zero foreach (SpectraFileInfo info in heavyFiles) { updatedPeptide.SetIntensity(info, currentPeptide.GetIntensity(info)); updatedPeptide.SetDetectionType(info, currentPeptide.GetDetectionType(info)); } //set the other values to zero List <SpectraFileInfo> otherInfo = silacSpectraFileInfo.Where(x => !heavyFiles.Contains(x)).ToList(); foreach (SpectraFileInfo info in otherInfo) { updatedPeptide.SetIntensity(info, 0); updatedPeptide.SetDetectionType(info, DetectionType.NotDetected); } HashSet <FlashLFQ.ProteinGroup> originalGroups = currentPeptide.proteinGroups; HashSet <FlashLFQ.ProteinGroup> updatedGroups = new HashSet <FlashLFQ.ProteinGroup>(); foreach (FlashLFQ.ProteinGroup group in originalGroups) { string groupName = group.ProteinGroupName; groupName = groupName.Replace(label.MassDifference, ""); updatedGroups.Add(new FlashLFQ.ProteinGroup(groupName, group.GeneName, group.Organism)); } updatedPeptide.proteinGroups = updatedGroups; lfqPwsms[updatedPeptide.Sequence] = updatedPeptide; } } } } }