Examples with SearchParameters com.compomics.util.parameters.identification.search.SearchParameters used on opensource projects

Example 1 with SearchParameters

use of com.compomics.util.parameters.identification.search.SearchParameters in project peptide-shaker by compomics.

the class SpectrumIdentificationPanel method accuracySliderStateChanged.

// GEN-LAST:event_accuracySliderMouseWheelMoved
/**
 * Update the fragment ion annotation accuracy.
 *
 * @param evt
 */
private void accuracySliderStateChanged(javax.swing.event.ChangeEvent evt) {
    // GEN-FIRST:event_accuracySliderStateChanged
    SearchParameters searchParameters = peptideShakerGUI.getIdentificationParameters().getSearchParameters();
    double accuracy = (accuracySlider.getValue() / 100.0) * searchParameters.getFragmentIonAccuracy();
    peptideShakerGUI.getIdentificationParameters().getAnnotationParameters().setFragmentIonAccuracy(accuracy);
    peptideShakerGUI.updateSpectrumAnnotations();
    peptideShakerGUI.setDataSaved(false);
    accuracySlider.setToolTipText("Annotation Accuracy: " + Util.roundDouble(accuracy, 2) + " " + searchParameters.getFragmentAccuracyType());
    updateSpectrumSliderToolTip();
}

Example 2 with SearchParameters

use of com.compomics.util.parameters.identification.search.SearchParameters in project peptide-shaker by compomics.

the class SpectrumIdentificationPanel method updateSpectrum.

/**
 * Update the spectrum based on the currently selected PSM.
 */
public void updateSpectrum() {
    if (spectrumTable.getSelectedRow() != -1) {
        spectrumChartPanel.removeAll();
        String spectrumTitle = getSelectedSpectrumTitle();
        Spectrum currentSpectrum = peptideShakerGUI.getSpectrumProvider().getSpectrum(fileSelected, spectrumTitle);
        AnnotationParameters annotationParameters = peptideShakerGUI.getIdentificationParameters().getAnnotationParameters();
        long spectrumMatchKey = SpectrumMatch.getKey(fileSelected, spectrumTitle);
        SpectrumMatch spectrumMatch = identification.getSpectrumMatch(spectrumMatchKey);
        // get the selected spectrum
        if (currentSpectrum != null && currentSpectrum.getNPeaks() > 0) {
            Precursor precursor = currentSpectrum.getPrecursor();
            String chargeAsString = "";
            if (spectrumMatch != null) {
                if (spectrumMatch.getBestPeptideAssumption() != null) {
                    chargeAsString = Charge.toString(spectrumMatch.getBestPeptideAssumption().getIdentificationCharge());
                } else if (spectrumMatch.getBestTagAssumption() != null) {
                    chargeAsString = Charge.toString(spectrumMatch.getBestTagAssumption().getIdentificationCharge());
                }
            } else {
                chargeAsString = precursor.getPossibleChargesAsString();
            }
            double[] intensitiesAsArray = searchResultsTable.getSelectedRowCount() == 1 ? currentSpectrum.intensity : ArrayUtil.scaleToMax(currentSpectrum.intensity);
            spectrumPanel = new SpectrumPanel(currentSpectrum.mz, intensitiesAsArray, precursor.mz, chargeAsString, "", 40, false, false, false, 2, false);
            spectrumPanel.setKnownMassDeltas(peptideShakerGUI.getCurrentMassDeltas());
            spectrumPanel.setDeltaMassWindow(annotationParameters.getFragmentIonAccuracy());
            spectrumPanel.setBorder(null);
            spectrumPanel.setDataPointAndLineColor(peptideShakerGUI.getUtilitiesUserParameters().getSpectrumAnnotatedPeakColor(), 0);
            spectrumPanel.setPeakWaterMarkColor(peptideShakerGUI.getUtilitiesUserParameters().getSpectrumBackgroundPeakColor());
            spectrumPanel.setPeakWidth(peptideShakerGUI.getUtilitiesUserParameters().getSpectrumAnnotatedPeakWidth());
            spectrumPanel.setBackgroundPeakWidth(peptideShakerGUI.getUtilitiesUserParameters().getSpectrumBackgroundPeakWidth());
            // add the mirrored spectrum
            if (searchResultsTable.getSelectedRowCount() == 2) {
                spectrumPanel.addMirroredSpectrum(currentSpectrum.mz, ArrayUtil.scaleToMax(currentSpectrum.intensity), precursor.mz, chargeAsString, "", false, peptideShakerGUI.getUtilitiesUserParameters().getSpectrumAnnotatedMirroredPeakColor(), peptideShakerGUI.getUtilitiesUserParameters().getSpectrumAnnotatedMirroredPeakColor());
            }
        }
        // add spectrum annotations
        if (spectrumMatch != null) {
            SequenceProvider sequenceProvider = peptideShakerGUI.getSequenceProvider();
            IdentificationParameters identificationParameters = peptideShakerGUI.getIdentificationParameters();
            ModificationParameters modificationParameters = identificationParameters.getSearchParameters().getModificationParameters();
            SequenceMatchingParameters modificationSequenceMatchingParameters = identificationParameters.getModificationLocalizationParameters().getSequenceMatchingParameters();
            SearchParameters searchParameters = identificationParameters.getSearchParameters();
            DisplayParameters displayParameters = peptideShakerGUI.getDisplayParameters();
            int forwardIon = searchParameters.getForwardIons().get(0);
            int rewindIon = searchParameters.getRewindIons().get(0);
            if (currentSpectrum != null && spectrumPanel != null) {
                if (currentSpectrum.getNPeaks() > 0) {
                    int maxPrecursorCharge = 1;
                    String modifiedSequence = "";
                    HashSet<String> allModifications = new HashSet<>();
                    ArrayList<IonMatch[]> allAnnotations = new ArrayList<>();
                    ArrayList<Spectrum> allSpectra = new ArrayList<>();
                    ArrayList<String> selectedIndexes = new ArrayList<>();
                    SpecificAnnotationParameters specificAnnotationParameters = null;
                    for (int i = 0; i < searchResultsTable.getSelectedRowCount(); i++) {
                        SpectrumIdentificationAssumption currentAssumption = currentAssumptionsList.get(searchResultsTable.getSelectedRows()[i]);
                        if (currentAssumption != null) {
                            selectedIndexes.add((i + 1) + " " + Charge.toString(currentAssumption.getIdentificationCharge()));
                            if (currentAssumption instanceof PeptideAssumption) {
                                PeptideAssumption currentPeptideAssumption = (PeptideAssumption) currentAssumption;
                                Peptide peptide = currentPeptideAssumption.getPeptide();
                                PeptideSpectrumAnnotator peptideSpectrumAnnotator = new PeptideSpectrumAnnotator();
                                specificAnnotationParameters = peptideShakerGUI.getSpecificAnnotationParameters(fileSelected, spectrumTitle, currentPeptideAssumption);
                                IonMatch[] annotations = peptideSpectrumAnnotator.getSpectrumAnnotation(annotationParameters, specificAnnotationParameters, fileSelected, spectrumTitle, currentSpectrum, peptide, modificationParameters, sequenceProvider, modificationSequenceMatchingParameters);
                                allAnnotations.add(annotations);
                                allSpectra.add(currentSpectrum);
                                // add the spectrum annotations
                                if (i == 0) {
                                    // @TODO: the selection of the peak to annotate should be done outside the spectrum panel
                                    spectrumPanel.setAnnotations(SpectrumAnnotator.getSpectrumAnnotation(annotations), annotationParameters.getTiesResolution() == SpectrumAnnotator.TiesResolution.mostIntense);
                                    // add de novo sequencing
                                    spectrumPanel.addAutomaticDeNovoSequencing(peptide, annotations, forwardIon, rewindIon, annotationParameters.getDeNovoCharge(), annotationParameters.showForwardIonDeNovoTags(), annotationParameters.showRewindIonDeNovoTags(), false, modificationParameters, sequenceProvider, modificationSequenceMatchingParameters);
                                } else {
                                    spectrumPanel.setAnnotationsMirrored(SpectrumAnnotator.getSpectrumAnnotation(annotations));
                                    // add de novo sequencing
                                    spectrumPanel.addAutomaticDeNovoSequencing(peptide, annotations, forwardIon, rewindIon, annotationParameters.getDeNovoCharge(), annotationParameters.showForwardIonDeNovoTags(), annotationParameters.showRewindIonDeNovoTags(), true, modificationParameters, sequenceProvider, modificationSequenceMatchingParameters);
                                }
                                if (currentPeptideAssumption.getIdentificationCharge() > maxPrecursorCharge) {
                                    maxPrecursorCharge = currentPeptideAssumption.getIdentificationCharge();
                                }
                                if (!modifiedSequence.isEmpty()) {
                                    modifiedSequence += " vs. ";
                                }
                                modifiedSequence += peptide.getTaggedModifiedSequence(modificationParameters, sequenceProvider, modificationSequenceMatchingParameters, false, false, true, displayParameters.getDisplayedModifications());
                                allModifications.addAll(ModificationUtils.getAllModifications(peptide, modificationParameters, sequenceProvider, modificationSequenceMatchingParameters));
                            } else if (currentAssumption instanceof TagAssumption) {
                                TagAssumption tagAssumption = (TagAssumption) currentAssumption;
                                TagSpectrumAnnotator spectrumAnnotator = new TagSpectrumAnnotator();
                                specificAnnotationParameters = peptideShakerGUI.getSpecificAnnotationParameters(fileSelected, spectrumTitle, tagAssumption);
                                IonMatch[] annotations = spectrumAnnotator.getSpectrumAnnotation(annotationParameters, modificationParameters, modificationSequenceMatchingParameters, specificAnnotationParameters, fileSelected, spectrumTitle, currentSpectrum, tagAssumption.getTag());
                                // add the spectrum annotations
                                // @TODO: the selection of the peak to annotate should be done outside the spectrum panel
                                spectrumPanel.setAnnotations(SpectrumAnnotator.getSpectrumAnnotation(annotations), annotationParameters.getTiesResolution() == SpectrumAnnotator.TiesResolution.mostIntense);
                                // add de novo sequencing
                                spectrumPanel.addAutomaticDeNovoSequencing(tagAssumption.getTag(), annotations, forwardIon, rewindIon, annotationParameters.getDeNovoCharge(), annotationParameters.showForwardIonDeNovoTags(), annotationParameters.showRewindIonDeNovoTags(), false);
                                // get the modifications for the tag
                                allModifications.addAll(ModificationUtils.getAllModifications(tagAssumption.getTag(), modificationParameters, modificationSequenceMatchingParameters));
                                if (tagAssumption.getIdentificationCharge() > maxPrecursorCharge) {
                                    maxPrecursorCharge = tagAssumption.getIdentificationCharge();
                                }
                                if (!modifiedSequence.isEmpty()) {
                                    modifiedSequence += " vs. ";
                                }
                                modifiedSequence += tagAssumption.getTag().getTaggedModifiedSequence(modificationParameters, false, false, true, false, modificationSequenceMatchingParameters, displayParameters.getDisplayedModifications());
                            } else {
                                throw new UnsupportedOperationException("Spectrum annotation not implemented for identification assumption of type " + currentAssumption.getClass() + ".");
                            }
                        }
                    }
                    spectrumPanel.showAnnotatedPeaksOnly(!annotationParameters.showAllPeaks());
                    spectrumPanel.setYAxisZoomExcludesBackgroundPeaks(annotationParameters.yAxisZoomExcludesBackgroundPeaks());
                    peptideShakerGUI.updateAnnotationMenus(specificAnnotationParameters, maxPrecursorCharge, allModifications);
                    // update the spectrum title
                    if (searchResultsTable.getSelectedRowCount() == 1) {
                        ((TitledBorder) spectrumPanelPanel.getBorder()).setTitle(PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING + "Spectrum & Fragment Ions (" + modifiedSequence + "   " + maxPrecursorCharge + "   " + Util.roundDouble(currentSpectrum.getPrecursor().mz, 2) + " m/z)" + PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING);
                    } else if (searchResultsTable.getSelectedRowCount() == 2) {
                        ((TitledBorder) spectrumPanelPanel.getBorder()).setTitle(PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING + "Spectrum & Fragment Ions (" + modifiedSequence + ")" + PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING);
                    } else if (searchResultsTable.getSelectedRowCount() > 2) {
                        ((TitledBorder) spectrumPanelPanel.getBorder()).setTitle(PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING + "Spectrum & Fragment Ions (" + searchResultsTable.getSelectedRowCount() + " PSMs)" + PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING);
                    }
                    spectrumPanelPanel.repaint();
                    if (searchResultsTable.getSelectedRowCount() > 2) {
                        SearchParameters.MassAccuracyType fragmentAccuracyType = peptideShakerGUI.getIdentificationParameters().getSearchParameters().getFragmentAccuracyType();
                        double bubbleScale = annotationParameters.getFragmentIonAccuracy() * 10 * peptideShakerGUI.getBubbleScale();
                        DisplayParameters displayPreferences = peptideShakerGUI.getDisplayParameters();
                        MassErrorBubblePlot massErrorBubblePlot = new MassErrorBubblePlot(selectedIndexes, allAnnotations, allSpectra, annotationParameters.getFragmentIonAccuracy(), bubbleScale, selectedIndexes.size() == 1, displayPreferences.showBars(), fragmentAccuracyType == SearchParameters.MassAccuracyType.PPM);
                        // hide the legend if selecting more than 20 spectra // @TODO: 20 should not be hardcoded here..
                        if (selectedIndexes.size() > 20) {
                            massErrorBubblePlot.getChartPanel().getChart().getLegend().setVisible(false);
                        }
                        // hide the outline
                        massErrorBubblePlot.getChartPanel().getChart().getPlot().setOutlineVisible(false);
                        spectrumChartPanel.add(massErrorBubblePlot);
                    }
                }
            }
            if (searchResultsTable.getSelectedRowCount() <= 2) {
                spectrumChartPanel.add(spectrumPanel);
            }
        } else {
            // update the spectrum title
            ((TitledBorder) spectrumPanelPanel.getBorder()).setTitle(PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING + "Spectrum & Fragment Ions (" + Util.roundDouble(currentSpectrum.getPrecursor().mz, 2) + " m/z)" + PeptideShakerGUI.TITLED_BORDER_HORIZONTAL_PADDING);
            if (currentSpectrum.getNPeaks() > 0) {
                spectrumChartPanel.add(spectrumPanel);
            }
            spectrumPanelPanel.repaint();
        }
    }
    spectrumChartPanel.revalidate();
    spectrumChartPanel.repaint();
}

Example 3 with SearchParameters

use of com.compomics.util.parameters.identification.search.SearchParameters in project peptide-shaker by compomics.

the class ModificationLocalizationScorer method attachProbabilisticScore.

/**
 * Attaches the selected probabilistic modification score.
 *
 * @param spectrumMatch The spectrum match studied, the score will be
 * calculated for the best assumption only.
 * @param sequenceProvider The protein sequence provider to use.
 * @param spectrumProvider The spectrum provider to use.
 * @param modificationProvider The modification provider to use.
 * @param identificationParameters The identification parameters.
 * @param peptideSpectrumAnnotator The peptide spectrum annotator to use.
 * @param identification The identification object containing the matches.
 */
private void attachProbabilisticScore(SpectrumMatch spectrumMatch, SequenceProvider sequenceProvider, SpectrumProvider spectrumProvider, ModificationProvider modificationProvider, IdentificationParameters identificationParameters, PeptideSpectrumAnnotator peptideSpectrumAnnotator, Identification identification) {
    SearchParameters searchParameters = identificationParameters.getSearchParameters();
    AnnotationParameters annotationParameters = identificationParameters.getAnnotationParameters();
    ModificationLocalizationParameters scoringParameters = identificationParameters.getModificationLocalizationParameters();
    SequenceMatchingParameters sequenceMatchingParameters = identificationParameters.getSequenceMatchingParameters();
    SequenceMatchingParameters modificationSequenceMatchingParameters = scoringParameters.getSequenceMatchingParameters();
    ModificationParameters modificationParameters = searchParameters.getModificationParameters();
    PSModificationScores modificationScores = (PSModificationScores) spectrumMatch.getUrParam(PSModificationScores.dummy);
    if (modificationScores != null) {
        modificationScores = new PSModificationScores();
        spectrumMatch.addUrParam(modificationScores);
    }
    HashMap<Double, ArrayList<Modification>> modificationsMap = new HashMap<>(1);
    HashMap<Double, Integer> nMod = new HashMap<>(1);
    PeptideAssumption bestPeptideAssumption = spectrumMatch.getBestPeptideAssumption();
    Peptide peptide = bestPeptideAssumption.getPeptide();
    for (ModificationMatch modificationMatch : peptide.getVariableModifications()) {
        Modification refMod = modificationProvider.getModification(modificationMatch.getModification());
        double modMass = refMod.getMass();
        if (!modificationsMap.containsKey(modMass)) {
            ArrayList<Modification> modifications = modificationFactory.getSameMassNotFixedModifications(modMass, searchParameters).stream().map(modification -> modificationProvider.getModification(modification)).collect(Collectors.toCollection(ArrayList::new));
            modificationsMap.put(modMass, modifications);
            nMod.put(modMass, 1);
        } else {
            nMod.put(modMass, nMod.get(modMass) + 1);
        }
    }
    if (!modificationsMap.isEmpty()) {
        String spectrumFile = spectrumMatch.getSpectrumFile();
        String spectrumTitle = spectrumMatch.getSpectrumTitle();
        Spectrum spectrum = spectrumProvider.getSpectrum(spectrumFile, spectrumTitle);
        SpecificAnnotationParameters specificAnnotationParameters = annotationParameters.getSpecificAnnotationParameters(spectrumFile, spectrumTitle, bestPeptideAssumption, modificationParameters, sequenceProvider, modificationSequenceMatchingParameters, peptideSpectrumAnnotator);
        for (double modMass : modificationsMap.keySet()) {
            HashMap<Integer, Double> scores = null;
            if (scoringParameters.getSelectedProbabilisticScore() == ModificationLocalizationScore.PhosphoRS) {
                scores = PhosphoRS.getSequenceProbabilities(peptide, modificationsMap.get(modMass), modificationParameters, spectrum, sequenceProvider, annotationParameters, specificAnnotationParameters, scoringParameters.isProbabilisticScoreNeutralLosses(), sequenceMatchingParameters, modificationSequenceMatchingParameters, peptideSpectrumAnnotator);
                if (scores == null) {
                    throw new IllegalArgumentException("An error occurred while scoring spectrum " + spectrumTitle + " of file " + spectrumFile + " with PhosphoRS.");
                // Most likely a compatibility issue with utilities
                }
            }
            if (scores != null) {
                // remap to searched modifications
                Modification mappedModification = null;
                String peptideSequence = peptide.getSequence();
                for (int site : scores.keySet()) {
                    if (site == 0) {
                        // N-term mod
                        for (Modification modification : modificationsMap.get(modMass)) {
                            if (modification.getModificationType().isNTerm()) {
                                mappedModification = modification;
                                break;
                            }
                        }
                        if (mappedModification == null) {
                            throw new IllegalArgumentException("Could not map the PTM of mass " + modMass + " on the N-terminus of the peptide " + peptideSequence + ".");
                        }
                    } else if (site == peptideSequence.length() + 1) {
                        // C-term mod
                        for (Modification modification : modificationsMap.get(modMass)) {
                            if (modification.getModificationType().isCTerm()) {
                                mappedModification = modification;
                                break;
                            }
                        }
                        if (mappedModification == null) {
                            throw new IllegalArgumentException("Could not map the PTM of mass " + modMass + " on the C-terminus of the peptide " + peptideSequence + ".");
                        }
                    } else {
                        for (Modification modification : modificationsMap.get(modMass)) {
                            mappedModification = modification;
                            break;
                        }
                        if (mappedModification == null) {
                            throw new IllegalArgumentException("Could not map the PTM of mass " + modMass + " at site " + site + " in peptide " + peptide.getSequence() + ".");
                        }
                    }
                    String modName = mappedModification.getName();
                    ModificationScoring modificationScoring = modificationScores.getModificationScoring(modName);
                    if (modificationScoring == null) {
                        modificationScoring = new ModificationScoring(modName);
                        modificationScores.addModificationScoring(modName, modificationScoring);
                    }
                    modificationScoring.setProbabilisticScore(site, scores.get(site));
                }
            }
        }
        identification.updateObject(spectrumMatch.getKey(), spectrumMatch);
    }
}

Example 4 with SearchParameters

use of com.compomics.util.parameters.identification.search.SearchParameters in project peptide-shaker by compomics.

the class ModificationLocalizationScorer method modificationSiteInference.

/**
 * Infers the modification site of the best peptide assumption of the given
 * spectrum match.
 *
 * @param spectrumMatch The spectrum match.
 * @param sequenceProvider The sequence provider to use.
 * @param modificationProvider The modification provider to use.
 * @param identificationParameters The identification parameters.
 */
public void modificationSiteInference(SpectrumMatch spectrumMatch, SequenceProvider sequenceProvider, ModificationProvider modificationProvider, IdentificationParameters identificationParameters) {
    Peptide peptide = spectrumMatch.getBestPeptideAssumption().getPeptide();
    int nVariableModifications = peptide.getNVariableModifications();
    if (nVariableModifications > 0) {
        SearchParameters searchParameters = identificationParameters.getSearchParameters();
        PSModificationScores modificationScores = (PSModificationScores) spectrumMatch.getUrParam(PSModificationScores.dummy);
        HashMap<Double, ArrayList<ModificationMatch>> modMatchesMap = new HashMap<>(nVariableModifications);
        HashMap<Double, HashMap<Integer, String>> possiblePositions = new HashMap<>(nVariableModifications);
        HashMap<Double, HashMap<Integer, ArrayList<String>>> confidentSites = new HashMap<>(nVariableModifications);
        for (ModificationMatch modificationMatch : peptide.getVariableModifications()) {
            String modName = modificationMatch.getModification();
            Modification modification = modificationProvider.getModification(modName);
            double modMass = modification.getMass();
            ArrayList<ModificationMatch> modOccurence = modMatchesMap.get(modMass);
            if (modOccurence == null) {
                modOccurence = new ArrayList<>(1);
                modMatchesMap.put(modMass, modOccurence);
            }
            HashMap<Integer, String> modPossibleSites = possiblePositions.get(modMass);
            if (modPossibleSites == null) {
                modPossibleSites = new HashMap<>(1);
                possiblePositions.put(modMass, modPossibleSites);
            }
            boolean maybeNotTerminal = modification.getModificationType() == ModificationType.modaa;
            if (!maybeNotTerminal) {
                ArrayList<String> expectedModifications = modificationFactory.getExpectedVariableModifications(searchParameters);
                for (String otherModName : expectedModifications) {
                    if (!otherModName.equals(modName)) {
                        Modification otherModification = modificationProvider.getModification(otherModName);
                        if (otherModification.getMass() == modMass && modification.getModificationType() != otherModification.getModificationType()) {
                            maybeNotTerminal = true;
                            break;
                        }
                    }
                }
            }
            if (maybeNotTerminal) {
                modOccurence.add(modificationMatch);
                for (String similarModName : modificationFactory.getSameMassNotFixedModifications(modMass, searchParameters)) {
                    Modification similarModification = modificationProvider.getModification(similarModName);
                    if (modification.getMass() == modMass) {
                        int[] possibleSites = ModificationUtils.getPossibleModificationSites(peptide, similarModification, sequenceProvider, identificationParameters.getModificationLocalizationParameters().getSequenceMatchingParameters());
                        for (int pos : possibleSites) {
                            modPossibleSites.put(pos, similarModName);
                        }
                    }
                }
            } else {
                ModificationScoring modificationScoring = modificationScores.getModificationScoring(modName);
                if (modificationScoring == null) {
                    modificationScoring = new ModificationScoring(modName);
                    modificationScores.addModificationScoring(modName, modificationScoring);
                }
                modificationScoring.setSiteConfidence(modificationMatch.getSite(), ModificationScoring.VERY_CONFIDENT);
                modificationMatch.setConfident(true);
                HashMap<Integer, ArrayList<String>> modificationSites = confidentSites.get(modification.getMass());
                if (modificationSites == null) {
                    modificationSites = new HashMap<>(1);
                    confidentSites.put(modMass, modificationSites);
                }
                int site = modificationMatch.getSite();
                ArrayList<String> modNames = modificationSites.get(site);
                if (modNames == null) {
                    modNames = new ArrayList<>(1);
                    modificationSites.put(site, modNames);
                }
                modNames.add(modName);
            }
        }
        ModificationLocalizationParameters modificationScoringParameters = identificationParameters.getModificationLocalizationParameters();
        Set<Double> modMasses = modMatchesMap.keySet();
        // p score -> d-score -> Map mod mass -> site -> list of modifications
        TreeMap<Double, TreeMap<Double, TreeMap<Double, HashMap<Integer, HashSet<String>>>>> ambiguousScoreToSiteMap = new TreeMap<>();
        HashMap<Double, Integer> nRepresentativesMap = new HashMap<>(modMasses.size());
        ArrayList<ModificationMatch> assignedModifications = new ArrayList<>(peptide.getNVariableModifications());
        // p-score -> d-score -> mod mass -> list of posssible sites
        TreeMap<Double, TreeMap<Double, TreeMap<Double, TreeSet<Integer>>>> scoreToSiteMap = new TreeMap<>();
        for (double modMass : modMasses) {
            ArrayList<ModificationMatch> modificationMatches = modMatchesMap.get(modMass);
            int nMods = modificationMatches.size();
            HashMap<Integer, String> modificationPossibleSites = possiblePositions.get(modMass);
            int nPossibleSites = modificationPossibleSites.size();
            HashMap<Integer, ArrayList<String>> modificationConfidentSites = confidentSites.get(modMass);
            if (modificationConfidentSites == null) {
                modificationConfidentSites = new HashMap<>(1);
                confidentSites.put(modMass, modificationConfidentSites);
            }
            if (nPossibleSites < nMods) {
                throw new IllegalArgumentException("The occurence of modification of mass " + modMass + " (" + modificationMatches.size() + ") is higher than the number of possible sites (" + modificationPossibleSites.size() + ") on sequence " + peptide.getSequence() + " in spectrum " + spectrumMatch.getKey() + ".");
            } else if (modificationPossibleSites.size() == modificationMatches.size()) {
                for (ModificationMatch modMatch : modificationMatches) {
                    String modName = modMatch.getModification();
                    int site = modMatch.getSite();
                    ModificationScoring modificationScoring = modificationScores.getModificationScoring(modName);
                    if (modificationScoring == null) {
                        modificationScoring = new ModificationScoring(modName);
                        modificationScores.addModificationScoring(modName, modificationScoring);
                    }
                    modificationScoring.setSiteConfidence(site, ModificationScoring.VERY_CONFIDENT);
                    modMatch.setConfident(true);
                    ArrayList<String> modificationsAtAA = modificationConfidentSites.get(site);
                    if (modificationsAtAA == null) {
                        modificationsAtAA = new ArrayList<>(1);
                        modificationConfidentSites.put(site, modificationsAtAA);
                    }
                    modificationsAtAA.add(modName);
                    assignedModifications.add(modMatch);
                }
            } else if (!modificationScoringParameters.isProbabilisticScoreCalculation()) {
                // no probabilistic score in that case
                double pScore = 0;
                for (ModificationMatch modificationMatch : modificationMatches) {
                    String modName = modificationMatch.getModification();
                    ModificationScoring modificationScoring = modificationScores.getModificationScoring(modName);
                    int site = modificationMatch.getSite();
                    Double dScore = modificationScoring.getDeltaScore(site);
                    if (dScore == 0.0) {
                        modificationScoring.setSiteConfidence(site, ModificationScoring.RANDOM);
                        modificationMatch.setConfident(false);
                    } else if (dScore <= 95) {
                        modificationScoring.setSiteConfidence(site, ModificationScoring.DOUBTFUL);
                        modificationMatch.setConfident(false);
                    } else {
                        modificationScoring.setSiteConfidence(site, ModificationScoring.CONFIDENT);
                        modificationMatch.setConfident(true);
                        ArrayList<String> modificationsAtAA = modificationConfidentSites.get(site);
                        if (modificationsAtAA == null) {
                            modificationsAtAA = new ArrayList<>(1);
                            modificationConfidentSites.put(site, modificationsAtAA);
                        }
                        modificationsAtAA.add(modName);
                    }
                    if (!modificationMatch.getConfident()) {
                        TreeMap<Double, TreeMap<Double, HashMap<Integer, HashSet<String>>>> pScoreAmbiguousMap = ambiguousScoreToSiteMap.get(pScore);
                        if (pScoreAmbiguousMap == null) {
                            pScoreAmbiguousMap = new TreeMap<>();
                            ambiguousScoreToSiteMap.put(pScore, pScoreAmbiguousMap);
                        }
                        TreeMap<Double, HashMap<Integer, HashSet<String>>> dScoreAmbiguousMap = pScoreAmbiguousMap.get(dScore);
                        if (dScoreAmbiguousMap == null) {
                            dScoreAmbiguousMap = new TreeMap<>();
                            pScoreAmbiguousMap.put(dScore, dScoreAmbiguousMap);
                        }
                        HashMap<Integer, HashSet<String>> massAmbiguousMap = dScoreAmbiguousMap.get(modMass);
                        if (massAmbiguousMap == null) {
                            massAmbiguousMap = new HashMap<>(nPossibleSites);
                            dScoreAmbiguousMap.put(modMass, massAmbiguousMap);
                        }
                        HashSet<String> modifications = massAmbiguousMap.get(site);
                        if (modifications == null) {
                            modifications = new HashSet<>(1);
                            massAmbiguousMap.put(site, modifications);
                        }
                        modifications.add(modName);
                    }
                    assignedModifications.add(modificationMatch);
                }
            } else {
                for (int site : modificationPossibleSites.keySet()) {
                    String modName = modificationPossibleSites.get(site);
                    ModificationScoring modificationScoring = modificationScores.getModificationScoring(modName);
                    double pScore = 0;
                    double dScore = 0;
                    if (modificationScoring != null) {
                        pScore = modificationScoring.getProbabilisticScore(site);
                        dScore = modificationScoring.getDeltaScore(site);
                    }
                    TreeMap<Double, TreeMap<Double, TreeSet<Integer>>> pScoreMap = scoreToSiteMap.get(pScore);
                    if (pScoreMap == null) {
                        pScoreMap = new TreeMap<>();
                        scoreToSiteMap.put(pScore, pScoreMap);
                    }
                    TreeMap<Double, TreeSet<Integer>> dScoreMap = pScoreMap.get(dScore);
                    if (dScoreMap == null) {
                        dScoreMap = new TreeMap<>();
                        pScoreMap.put(dScore, dScoreMap);
                    }
                    TreeSet<Integer> dScoreSites = dScoreMap.get(modMass);
                    if (dScoreSites == null) {
                        dScoreSites = new TreeSet<>();
                        dScoreMap.put(modMass, dScoreSites);
                    }
                    dScoreSites.add(site);
                }
            }
        }
        // Assign modifications to the sites passing the threshold.
        if (!scoreToSiteMap.isEmpty()) {
            HashMap<Double, Integer> processedSitesMap = new HashMap<>(modMasses.size());
            for (Entry<Double, TreeMap<Double, TreeMap<Double, TreeSet<Integer>>>> entry1 : scoreToSiteMap.descendingMap().entrySet()) {
                double pScore = entry1.getKey();
                TreeMap<Double, TreeMap<Double, TreeSet<Integer>>> pScoreMap = entry1.getValue();
                for (Entry<Double, TreeMap<Double, TreeSet<Integer>>> entry2 : pScoreMap.descendingMap().entrySet()) {
                    double dScore = entry2.getKey();
                    TreeMap<Double, TreeSet<Integer>> dScoreMap = entry2.getValue();
                    for (Entry<Double, TreeSet<Integer>> entry : dScoreMap.entrySet()) {
                        double modificationMass = entry.getKey();
                        ArrayList<ModificationMatch> modificationMatches = modMatchesMap.get(modificationMass);
                        HashMap<Integer, String> modificationPossibleSites = possiblePositions.get(modificationMass);
                        HashMap<Integer, ArrayList<String>> modificationConfidentSites = confidentSites.get(modificationMass);
                        int nMods = modificationMatches.size();
                        int nPossibleSites = modificationPossibleSites.size();
                        double randomScoreThreshold = modificationScoringParameters.getSelectedProbabilisticScore().getRandomThreshold(nMods, nPossibleSites);
                        double confidenceThreshold = modificationScoringParameters.getProbabilisticScoreThreshold();
                        TreeSet<Integer> sites = dScoreMap.get(modificationMass);
                        Integer nAssignedSites = processedSitesMap.get(modificationMass);
                        if (nAssignedSites == null) {
                            nAssignedSites = 0;
                        }
                        for (int site : sites) {
                            String modName = modificationPossibleSites.get(site);
                            ModificationScoring modificationScoring = modificationScores.getModificationScoring(modName);
                            if (modificationScoring == null) {
                                modificationScoring = new ModificationScoring(modName);
                                modificationScores.addModificationScoring(modName, modificationScoring);
                            }
                            ModificationMatch modificationMatch = null;
                            if (nAssignedSites < nMods) {
                                boolean alreadyOccupied = false;
                                for (ModificationMatch assignedMatch : assignedModifications) {
                                    if (assignedMatch.getSite() == site) {
                                        alreadyOccupied = true;
                                        break;
                                    }
                                }
                                if (!alreadyOccupied) {
                                    if (pScore >= confidenceThreshold) {
                                        modificationMatch = modificationMatches.get(nAssignedSites);
                                        modificationMatch.setSite(site);
                                        modificationMatch.setModification(modName);
                                        assignedModifications.add(modificationMatch);
                                        modificationScoring.setSiteConfidence(site, ModificationScoring.VERY_CONFIDENT);
                                        modificationMatch.setConfident(true);
                                        ArrayList<String> modificationsAtAA = modificationConfidentSites.get(site);
                                        if (modificationsAtAA == null) {
                                            modificationsAtAA = new ArrayList<>(1);
                                            modificationConfidentSites.put(site, modificationsAtAA);
                                        }
                                        modificationsAtAA.add(modName);
                                        nAssignedSites++;
                                        processedSitesMap.put(modificationMass, nAssignedSites);
                                    } else if (pScore > randomScoreThreshold) {
                                        modificationScoring.setSiteConfidence(site, ModificationScoring.DOUBTFUL);
                                    } else {
                                        modificationScoring.setSiteConfidence(site, ModificationScoring.RANDOM);
                                    }
                                }
                            }
                            if (modificationMatch == null) {
                                TreeMap<Double, TreeMap<Double, HashMap<Integer, HashSet<String>>>> pScoreAmbiguousMap = ambiguousScoreToSiteMap.get(pScore);
                                if (pScoreAmbiguousMap == null) {
                                    pScoreAmbiguousMap = new TreeMap<>();
                                    ambiguousScoreToSiteMap.put(pScore, pScoreAmbiguousMap);
                                }
                                TreeMap<Double, HashMap<Integer, HashSet<String>>> dScoreAmbiguousMap = pScoreAmbiguousMap.get(dScore);
                                if (dScoreAmbiguousMap == null) {
                                    dScoreAmbiguousMap = new TreeMap<>();
                                    pScoreAmbiguousMap.put(dScore, dScoreAmbiguousMap);
                                }
                                HashMap<Integer, HashSet<String>> massAmbiguousMap = dScoreAmbiguousMap.get(modificationMass);
                                if (massAmbiguousMap == null) {
                                    massAmbiguousMap = new HashMap<>(nPossibleSites);
                                    dScoreAmbiguousMap.put(modificationMass, massAmbiguousMap);
                                }
                                HashSet<String> modifications = massAmbiguousMap.get(site);
                                if (modifications == null) {
                                    modifications = new HashSet<>(1);
                                    massAmbiguousMap.put(site, modifications);
                                }
                                modifications.add(modName);
                            }
                        }
                    }
                }
            }
        }
        // See whether there are sites that are not confidently assigned.
        for (double modMass : confidentSites.keySet()) {
            HashMap<Integer, ArrayList<String>> modConfidentSitesMap = confidentSites.get(modMass);
            ArrayList<Integer> modConfidentSites = new ArrayList<>(modConfidentSitesMap.keySet());
            int nConfident = 0;
            for (int site : modConfidentSites) {
                ArrayList<String> modifications = modConfidentSitesMap.get(site);
                for (String modName : modifications) {
                    modificationScores.addConfidentModificationSite(modName, site);
                }
                nConfident += modifications.size();
            }
            modConfidentSites.size();
            ArrayList<ModificationMatch> modificationMatches = modMatchesMap.get(modMass);
            int nMods = modificationMatches.size();
            if (nConfident < nMods) {
                int nRepresentatives = nMods - nConfident;
                if (nRepresentatives > 0) {
                    nRepresentativesMap.put(modMass, nRepresentatives);
                }
            }
        }
        // Create ambiguous site groups and assign the remaining modifications to the best scoring sites.
        if (!nRepresentativesMap.isEmpty()) {
            HashMap<Double, HashMap<Integer, HashMap<Integer, HashSet<String>>>> representativeToSecondaryMap = getRepresentativeToSecondaryMap(ambiguousScoreToSiteMap, nRepresentativesMap);
            for (Entry<Double, HashMap<Integer, HashMap<Integer, HashSet<String>>>> entry1 : representativeToSecondaryMap.entrySet()) {
                double modMass = entry1.getKey();
                HashMap<Integer, HashMap<Integer, HashSet<String>>> massMap = entry1.getValue();
                ArrayList<ModificationMatch> modificationMatches = modMatchesMap.get(modMass);
                int nMods = modificationMatches.size();
                int nRepresentativeSites = nRepresentativesMap.get(modMass);
                if (nRepresentativeSites != massMap.size()) {
                    throw new IllegalArgumentException("Unexpected number of representative sites.");
                }
                int nConfident = nMods - nRepresentativeSites;
                int modMatchIndex = nConfident;
                for (Entry<Integer, HashMap<Integer, HashSet<String>>> entry : massMap.entrySet()) {
                    int representativeSite = entry.getKey();
                    HashMap<Integer, HashSet<String>> sites = entry.getValue();
                    modificationScores.addAmbiguousModificationSites(representativeSite, sites);
                    ModificationMatch modificationMatch = modificationMatches.get(modMatchIndex);
                    String modName = null;
                    for (String possibleModName : sites.get(representativeSite)) {
                        Modification possibleModification = modificationProvider.getModification(possibleModName);
                        if (possibleModification.getMass() == modMass) {
                            modName = possibleModName;
                            break;
                        }
                    }
                    if (modName == null) {
                        throw new IllegalArgumentException("No candidate modification of mass " + modMass + " found at site " + representativeSite + " on peptide " + peptide.getSequence() + ".");
                    }
                    modificationMatch.setModification(modName);
                    modificationMatch.setSite(representativeSite);
                    modificationMatch.setConfident(false);
                    modMatchIndex++;
                }
            }
        }
    }
}

Example 5 with SearchParameters

use of com.compomics.util.parameters.identification.search.SearchParameters in project peptide-shaker by compomics.

the class QCPanel method getPsmDataset.

/**
 * Returns the dataset to use for the PSM QC plot.
 */
private void getPsmDataset() {
    progressDialog.setPrimaryProgressCounterIndeterminate(false);
    progressDialog.setMaxPrimaryProgressCounter(peptideShakerGUI.getIdentification().getSpectrumIdentificationSize());
    progressDialog.setValue(0);
    maxValue = Double.MIN_VALUE;
    if (psmPrecursorMassErrorJRadioButton.isSelected()) {
        // values for the precursor mass deviation
        validatedValues = new ArrayList<>();
        validatedDoubtfulValues = new ArrayList<>();
        nonValidatedValues = new ArrayList<>();
        validatedDecoyValues = new ArrayList<>();
        nonValidatedDecoyValues = new ArrayList<>();
        SpectrumMatchesIterator psmIterator = peptideShakerGUI.getIdentification().getSpectrumMatchesIterator(progressDialog);
        SpectrumMatch spectrumMatch;
        while ((spectrumMatch = psmIterator.next()) != null) {
            if (progressDialog.isRunCanceled()) {
                break;
            }
            PSParameter psmParameter = (PSParameter) spectrumMatch.getUrParam(PSParameter.dummy);
            if (!psmParameter.getHidden() && spectrumMatch.getBestPeptideAssumption() != null) {
                String spectrumFile = spectrumMatch.getSpectrumFile();
                String spectrumTitle = spectrumMatch.getSpectrumTitle();
                double precursorMz = peptideShakerGUI.getSpectrumProvider().getPrecursorMz(spectrumFile, spectrumTitle);
                SearchParameters searchParameters = peptideShakerGUI.getIdentificationParameters().getSearchParameters();
                double value = spectrumMatch.getBestPeptideAssumption().getDeltaMz(precursorMz, searchParameters.isPrecursorAccuracyTypePpm(), searchParameters.getMinIsotopicCorrection(), searchParameters.getMaxIsotopicCorrection());
                if (value > maxValue) {
                    maxValue = value;
                }
                if (!PeptideUtils.isDecoy(spectrumMatch.getBestPeptideAssumption().getPeptide(), peptideShakerGUI.getSequenceProvider())) {
                    if (psmParameter.getMatchValidationLevel().isValidated()) {
                        if (psmParameter.getMatchValidationLevel() == MatchValidationLevel.confident) {
                            validatedValues.add(value);
                        } else {
                            validatedDoubtfulValues.add(value);
                        }
                    } else {
                        nonValidatedValues.add(value);
                    }
                } else if (psmParameter.getMatchValidationLevel().isValidated()) {
                    validatedDecoyValues.add(value);
                } else {
                    nonValidatedDecoyValues.add(value);
                }
            }
            progressDialog.increasePrimaryProgressCounter();
        }
    } else if (psmPrecursorChargeJRadioButton.isSelected()) {
        // values for the precursor charge
        validatedValues = new ArrayList<>();
        validatedDoubtfulValues = new ArrayList<>();
        nonValidatedValues = new ArrayList<>();
        validatedDecoyValues = new ArrayList<>();
        nonValidatedDecoyValues = new ArrayList<>();
        SpectrumMatchesIterator psmIterator = peptideShakerGUI.getIdentification().getSpectrumMatchesIterator(progressDialog);
        SpectrumMatch spectrumMatch;
        while ((spectrumMatch = psmIterator.next()) != null) {
            if (progressDialog.isRunCanceled()) {
                break;
            }
            PSParameter psmParameter = (PSParameter) spectrumMatch.getUrParam(PSParameter.dummy);
            if (!psmParameter.getHidden() && spectrumMatch.getBestPeptideAssumption() != null) {
                double value = spectrumMatch.getBestPeptideAssumption().getIdentificationCharge();
                if (value > maxValue) {
                    maxValue = value;
                }
                if (!PeptideUtils.isDecoy(spectrumMatch.getBestPeptideAssumption().getPeptide(), peptideShakerGUI.getSequenceProvider())) {
                    if (psmParameter.getMatchValidationLevel().isValidated()) {
                        if (psmParameter.getMatchValidationLevel() == MatchValidationLevel.confident) {
                            validatedValues.add(value);
                        } else {
                            validatedDoubtfulValues.add(value);
                        }
                    } else {
                        nonValidatedValues.add(value);
                    }
                } else if (psmParameter.getMatchValidationLevel().isValidated()) {
                    validatedDecoyValues.add(value);
                } else {
                    nonValidatedDecoyValues.add(value);
                }
            }
            progressDialog.increasePrimaryProgressCounter();
        }
    }
}