コード例 #1
0
  public void clearData(boolean clearDatabaseFolder) {
    projectDetails = null;
    spectrumAnnotator = new SpectrumAnnotator();
    try {
      spectrumFactory.closeFiles();
    } catch (Exception e) {
      e.printStackTrace();
    }
    try {
      sequenceFactory.closeFile();
    } catch (Exception e) {
      e.printStackTrace();
    }
    try {
      GOFactory.getInstance().closeFiles();
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      spectrumFactory.clearFactory();
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      sequenceFactory.clearFactory();
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      GOFactory.getInstance().clearFactory();
    } catch (Exception e) {
      e.printStackTrace();
    }

    identifiedModifications = null;

    if (clearDatabaseFolder) {
      clearDatabaseFolder();
    }

    resetFeatureGenerator();

    // set up the tabs/panels

    currentPSFile = null;
  }
コード例 #2
0
 /**
  * Returns the desired spectrum.
  *
  * @param spectrumKey the key of the spectrum
  * @return the desired spectrum
  */
 public MSnSpectrum getSpectrum(String spectrumKey) {
   String spectrumFile = Spectrum.getSpectrumFile(spectrumKey);
   String spectrumTitle = Spectrum.getSpectrumTitle(spectrumKey);
   try {
     return (MSnSpectrum) spectrumFactory.getSpectrum(spectrumFile, spectrumTitle);
   } catch (Exception e) {
     System.out.println(e.getMessage());
     return null;
   }
 }
コード例 #3
0
/**
 * A Jump To panel for use in the menu bar in the main frame.
 *
 * @author Marc Vaudel
 * @author Harald Barsnes
 */
public class JumpToPanel extends javax.swing.JPanel {

  /** Enum of the types of data to jump to. */
  public enum JumpType {
    proteinAndPeptides,
    spectrum
  }
  /** The type of data to jump to in that panel. */
  private JumpType jumpType = JumpType.proteinAndPeptides;
  /** Instance of the main GUI class. */
  private PeptideShakerGUI peptideShakerGUI;
  /** Items matching the criterion for each type. */
  private HashMap<JumpType, ArrayList<String>> possibilities =
      new HashMap<JumpType, ArrayList<String>>();
  /** Currently selected item. */
  private HashMap<JumpType, Integer> currentSelection = new HashMap<JumpType, Integer>();
  /** The text to display by default. */
  private HashMap<JumpType, String> lastInput = new HashMap<JumpType, String>();
  /** The text to display by default. */
  private HashMap<JumpType, String> lastLabel = new HashMap<JumpType, String>();
  /** Instance of the sequence factory. */
  private SequenceFactory sequenceFactory = SequenceFactory.getInstance();
  /** The text to display by default. */
  private HashMap<JumpType, String> welcomeText;
  /** The spectrum factory. */
  private SpectrumFactory spectrumFactory = SpectrumFactory.getInstance();
  /** The spectrum file inspected when jumping to spectra. */
  private String spectrumfile;
  /** Counts the number of times the users has pressed a key on the keyboard in the search field. */
  private int keyPressedCounter = 0;
  /** The time to wait between keys typed before updating the search. */
  private int waitingTime = 1000;

  /** Type of item selected. */
  private enum Type {
    PROTEIN,
    PEPTIDE,
    SPECTRUM
  }
  /** Type of each possible item. */
  private HashMap<JumpType, ArrayList<Type>> types = new HashMap<JumpType, ArrayList<Type>>();

  /**
   * Creates a new JumpToPanel.
   *
   * @param peptideShakerGUI the parent
   */
  public JumpToPanel(PeptideShakerGUI peptideShakerGUI) {
    initComponents();

    this.peptideShakerGUI = peptideShakerGUI;

    welcomeText = new HashMap<JumpType, String>();
    welcomeText.put(JumpType.proteinAndPeptides, "(protein or peptide)");
    welcomeText.put(JumpType.spectrum, "(title, m/z or RT)");
    inputTxt.setText(welcomeText.get(jumpType));
    indexLabel.setText("");
    previousButton.setEnabled(false);
    nextButton.setEnabled(false);
  }

  /** Move the focus to the Jump To text field and select all the content. */
  public void selectTextField() {
    inputTxt.requestFocus();
    inputTxt.selectAll();
  }

  /**
   * Set the color for the hits.
   *
   * @param color the color
   */
  public void setColor(Color color) {
    indexLabel.setForeground(color);
  }

  /** Updates the item selection in the selected tab. */
  public void updateSelectionInTab() {

    indexLabel.setForeground(Color.BLACK);

    if (types.get(jumpType).get(currentSelection.get(jumpType)) == Type.PROTEIN) {
      peptideShakerGUI.setSelectedItems(
          possibilities.get(jumpType).get(currentSelection.get(jumpType)),
          PeptideShakerGUI.NO_SELECTION,
          PeptideShakerGUI.NO_SELECTION);
      peptideShakerGUI.updateSelectionInCurrentTab();
    } else if (types.get(jumpType).get(currentSelection.get(jumpType)) == Type.PEPTIDE) {
      peptideShakerGUI.setSelectedItems(
          PeptideShakerGUI.NO_SELECTION,
          possibilities.get(jumpType).get(currentSelection.get(jumpType)),
          PeptideShakerGUI.NO_SELECTION);
      if (peptideShakerGUI.getSelectedTab() == PeptideShakerGUI.MODIFICATIONS_TAB_INDEX
          && !peptideShakerGUI
              .getDisplayedPeptides()
              .contains(possibilities.get(jumpType).get(currentSelection.get(jumpType)))) {
        // warn the user that the current selection is not in the tab
        indexLabel.setForeground(Color.RED);
      } else {
        peptideShakerGUI.updateSelectionInCurrentTab();
      }
    } else {
      peptideShakerGUI.setSelectedItems(
          PeptideShakerGUI.NO_SELECTION,
          PeptideShakerGUI.NO_SELECTION,
          possibilities.get(jumpType).get(currentSelection.get(jumpType)));
      peptideShakerGUI.updateSelectionInCurrentTab();
    }
    String label =
        "("
            + (currentSelection.get(jumpType) + 1)
            + " of "
            + possibilities.get(jumpType).size()
            + ")";
    indexLabel.setText(label);
    lastLabel.put(jumpType, label);
  }

  /**
   * Returns a list of descriptions corresponding to every item matching the search.
   *
   * @return a list of descriptions
   * @throws SQLException thrown if an SQLException occurs
   * @throws ClassNotFoundException thrown if a ClassNotFoundException occurs
   * @throws IOException thrown if an IOException occurs
   * @throws InterruptedException thrown if an InterruptedException occurs
   */
  public ArrayList<String> getPossibilitiesDescriptions()
      throws SQLException, ClassNotFoundException, IOException, InterruptedException {

    Identification identification = peptideShakerGUI.getIdentification();

    // Some necessary pre-caching
    ArrayList<Type> typeList = types.get(jumpType);
    ArrayList<String> keys = possibilities.get(jumpType),
        proteinKeys = new ArrayList<String>(),
        peptideKeys = new ArrayList<String>();
    for (int i = 0; i < keys.size(); i++) {
      String key = keys.get(i);
      if (typeList.get(i) == Type.PROTEIN) {
        proteinKeys.add(key);
      } else if (typeList.get(i) == Type.PEPTIDE) {
        peptideKeys.add(key);
      }
    }
    if (!proteinKeys.isEmpty()) {
      identification.loadProteinMatches(proteinKeys, null, false);
    }
    if (!peptideKeys.isEmpty()) {
      identification.loadPeptideMatches(peptideKeys, null, false);
    }

    ArrayList<String> descriptions = new ArrayList<String>();
    for (int i = 0; i < keys.size(); i++) {
      String key = keys.get(i);
      Type type = typeList.get(i);
      String description = getItemDescription(key, type);
      descriptions.add(description);
    }
    return descriptions;
  }

  /**
   * Returns the description of an item.
   *
   * @param key the key of the item
   * @param itemType the type of the item
   * @return the description of an item
   * @throws SQLException thrown if an SQLException occurs
   * @throws ClassNotFoundException thrown if a ClassNotFoundException occurs
   * @throws IOException thrown if an IOException occurs
   * @throws InterruptedException thrown if an InterruptedException occurs
   */
  private String getItemDescription(String key, Type itemType)
      throws IllegalArgumentException, SQLException, IOException, ClassNotFoundException,
          InterruptedException {
    Identification identification = peptideShakerGUI.getIdentification();
    switch (itemType) {
      case PROTEIN:
        ProteinMatch proteinMatch = identification.getProteinMatch(key);
        String mainMatch = proteinMatch.getMainMatch();
        String description = sequenceFactory.getHeader(mainMatch).getSimpleProteinDescription();
        String result = mainMatch;
        for (String accession : ProteinMatch.getAccessions(key)) {
          if (!accession.equals(mainMatch)) {
            if (!result.equals(mainMatch)) {
              result += ", ";
            }
            result += accession;
          }
        }
        result += " - " + description;
        return result;
      case PEPTIDE:
        PeptideMatch peptideMatch = identification.getPeptideMatch(key);
        return peptideShakerGUI
            .getDisplayFeaturesGenerator()
            .getTaggedPeptideSequence(peptideMatch, true, true, true);
      case SPECTRUM:
        return Spectrum.getSpectrumTitle(key) + " (" + Spectrum.getSpectrumFile(key) + ")";
      default:
        return "Unknown";
    }
  }

  /**
   * Returns the index of the selected item.
   *
   * @return the index of the selected item
   */
  public int getIndexOfSelectedItem() {
    return currentSelection.get(jumpType);
  }

  /**
   * Sets the index of the selected item. Note: this does not update the selection in tab and the
   * GUI (see updateSelectionInTab()).
   *
   * @param itemIndex the item index
   */
  public void setSelectedItem(int itemIndex) {
    currentSelection.put(jumpType, itemIndex);
  }

  /**
   * This method is called from within the constructor to initialize the form. WARNING: Do NOT
   * modify this code. The content of this method is always regenerated by the Form Editor.
   */
  @SuppressWarnings("unchecked")
  // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
  private void initComponents() {

    findJLabel = new javax.swing.JLabel();
    inputTxt = new javax.swing.JTextField();
    previousButton = new javax.swing.JButton();
    nextButton = new javax.swing.JButton();
    indexLabel = new javax.swing.JLabel();

    setOpaque(false);

    findJLabel.setText("Find");

    inputTxt.setForeground(new java.awt.Color(204, 204, 204));
    inputTxt.setHorizontalAlignment(javax.swing.JTextField.CENTER);
    inputTxt.setText("(peptide or protein)");
    inputTxt.setBorder(
        javax.swing.BorderFactory.createLineBorder(new java.awt.Color(204, 204, 204)));
    inputTxt.addMouseListener(
        new java.awt.event.MouseAdapter() {
          public void mouseReleased(java.awt.event.MouseEvent evt) {
            inputTxtMouseReleased(evt);
          }
        });
    inputTxt.addKeyListener(
        new java.awt.event.KeyAdapter() {
          public void keyReleased(java.awt.event.KeyEvent evt) {
            inputTxtKeyReleased(evt);
          }
        });

    previousButton.setIcon(
        new javax.swing.ImageIcon(getClass().getResource("/icons/previous_grey.png"))); // NOI18N
    previousButton.setToolTipText("Previous");
    previousButton.setBorder(null);
    previousButton.setBorderPainted(false);
    previousButton.setContentAreaFilled(false);
    previousButton.setIconTextGap(0);
    previousButton.setRolloverIcon(
        new javax.swing.ImageIcon(getClass().getResource("/icons/previous.png"))); // NOI18N
    previousButton.addMouseListener(
        new java.awt.event.MouseAdapter() {
          public void mouseEntered(java.awt.event.MouseEvent evt) {
            previousButtonMouseEntered(evt);
          }

          public void mouseExited(java.awt.event.MouseEvent evt) {
            previousButtonMouseExited(evt);
          }
        });
    previousButton.addActionListener(
        new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
            previousButtonActionPerformed(evt);
          }
        });

    nextButton.setIcon(
        new javax.swing.ImageIcon(getClass().getResource("/icons/next_grey.png"))); // NOI18N
    nextButton.setToolTipText("Next");
    nextButton.setBorderPainted(false);
    nextButton.setContentAreaFilled(false);
    nextButton.setRolloverIcon(
        new javax.swing.ImageIcon(getClass().getResource("/icons/next.png"))); // NOI18N
    nextButton.addMouseListener(
        new java.awt.event.MouseAdapter() {
          public void mouseEntered(java.awt.event.MouseEvent evt) {
            nextButtonMouseEntered(evt);
          }

          public void mouseExited(java.awt.event.MouseEvent evt) {
            nextButtonMouseExited(evt);
          }
        });
    nextButton.addActionListener(
        new java.awt.event.ActionListener() {
          public void actionPerformed(java.awt.event.ActionEvent evt) {
            nextButtonActionPerformed(evt);
          }
        });

    indexLabel.setFont(
        indexLabel.getFont().deriveFont((indexLabel.getFont().getStyle() | java.awt.Font.ITALIC)));
    indexLabel.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
    indexLabel.setText(" ");

    javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
    this.setLayout(layout);
    layout.setHorizontalGroup(
        layout
            .createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(
                layout
                    .createSequentialGroup()
                    .addContainerGap()
                    .addComponent(findJLabel)
                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                    .addComponent(
                        inputTxt,
                        javax.swing.GroupLayout.PREFERRED_SIZE,
                        205,
                        javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                    .addComponent(
                        previousButton,
                        javax.swing.GroupLayout.PREFERRED_SIZE,
                        15,
                        javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addGap(0, 0, 0)
                    .addComponent(
                        nextButton,
                        javax.swing.GroupLayout.PREFERRED_SIZE,
                        15,
                        javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
                    .addComponent(
                        indexLabel,
                        javax.swing.GroupLayout.PREFERRED_SIZE,
                        97,
                        javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addContainerGap()));

    layout.linkSize(
        javax.swing.SwingConstants.HORIZONTAL,
        new java.awt.Component[] {nextButton, previousButton});

    layout.setVerticalGroup(
        layout
            .createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(
                layout
                    .createSequentialGroup()
                    .addContainerGap()
                    .addGroup(
                        layout
                            .createParallelGroup(javax.swing.GroupLayout.Alignment.CENTER)
                            .addComponent(findJLabel)
                            .addComponent(
                                inputTxt,
                                javax.swing.GroupLayout.PREFERRED_SIZE,
                                javax.swing.GroupLayout.DEFAULT_SIZE,
                                javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(indexLabel)
                            .addComponent(
                                previousButton,
                                javax.swing.GroupLayout.PREFERRED_SIZE,
                                15,
                                javax.swing.GroupLayout.PREFERRED_SIZE)
                            .addComponent(
                                nextButton,
                                javax.swing.GroupLayout.PREFERRED_SIZE,
                                15,
                                javax.swing.GroupLayout.PREFERRED_SIZE))
                    .addContainerGap()));
  } // </editor-fold>//GEN-END:initComponents

  /**
   * Update the jump to filter.
   *
   * @param evt the key event
   */
  private void inputTxtKeyReleased(
      java.awt.event.KeyEvent evt) { // GEN-FIRST:event_inputTxtKeyReleased

    final KeyEvent event = evt;
    keyPressedCounter++;

    new Thread("FindThread") {
      @Override
      public synchronized void run() {

        try {
          wait(waitingTime);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }

        try {
          // see if the gui is to be updated or not
          Identification identification = peptideShakerGUI.getIdentification();
          if (identification != null && keyPressedCounter == 1) {

            if (!inputTxt.getText().equalsIgnoreCase(welcomeText.get(jumpType))) {
              inputTxt.setForeground(Color.black);
            } else {
              inputTxt.setForeground(new Color(204, 204, 204));
            }

            if (event.getKeyCode() == KeyEvent.VK_UP && previousButton.isEnabled()) {
              previousButtonActionPerformed(null);
            } else if (event.getKeyCode() == KeyEvent.VK_DOWN && nextButton.isEnabled()) {
              nextButtonActionPerformed(null);
            } else {
              if (!possibilities.containsKey(jumpType)) {
                possibilities.put(jumpType, new ArrayList<String>());
                types.put(jumpType, new ArrayList<Type>());
              } else {
                possibilities.get(jumpType).clear();
                types.get(jumpType).clear();
              }
              currentSelection.put(jumpType, 0);
              String doubleString, input = inputTxt.getText().trim().toLowerCase();
              lastInput.put(jumpType, input);

              if (!input.equals("")) {

                peptideShakerGUI.setCursor(new java.awt.Cursor(java.awt.Cursor.WAIT_CURSOR));
                inputTxt.setCursor(new java.awt.Cursor(java.awt.Cursor.WAIT_CURSOR));

                if (jumpType == JumpType.proteinAndPeptides) {

                  for (String proteinKey :
                      peptideShakerGUI
                          .getIdentificationFeaturesGenerator()
                          .getProcessedProteinKeys(null, peptideShakerGUI.getFilterPreferences())) {
                    if (!ProteinMatch.isDecoy(proteinKey)) {
                      if (proteinKey.toLowerCase().contains(input)) {
                        possibilities.get(jumpType).add(proteinKey);
                        types.get(jumpType).add(Type.PROTEIN);
                      } else {
                        try {
                          for (String accession : ProteinMatch.getAccessions(proteinKey)) {
                            if (sequenceFactory
                                .getHeader(accession)
                                .getSimpleProteinDescription()
                                .toLowerCase()
                                .contains(input)) {
                              possibilities.get(jumpType).add(proteinKey);
                              types.get(jumpType).add(Type.PROTEIN);
                              break;
                            }
                          }
                        } catch (Exception e) {
                          // cannot get description, ignore
                        }
                      }
                    }
                  }

                  // check if it's a valid peptide sequence
                  boolean validPeptideSequence;
                  try {
                    AminoAcid.getMatchingSequence(
                        input,
                        peptideShakerGUI
                            .getIdentificationParameters()
                            .getSequenceMatchingPreferences());
                    validPeptideSequence = true;
                  } catch (IllegalArgumentException e) {
                    // ignore, not a peptide sequence
                    validPeptideSequence = false;
                  }

                  if (validPeptideSequence) {

                    ArrayList<String> secondaryCandidates = new ArrayList<String>();

                    // pre-caching
                    PSParameter psParameter = new PSParameter();
                    identification.loadPeptideMatchParameters(psParameter, null, false);
                    String matchingInput =
                        AminoAcid.getMatchingSequence(
                            input,
                            peptideShakerGUI
                                .getIdentificationParameters()
                                .getSequenceMatchingPreferences());

                    for (String peptideKey : identification.getPeptideIdentification()) {
                      try {
                        psParameter =
                            (PSParameter)
                                identification.getPeptideMatchParameter(peptideKey, psParameter);
                      } catch (Exception e) {
                        peptideShakerGUI.catchException(e);
                        return;
                      }
                      if (!psParameter.isHidden()) {
                        if (peptideKey.startsWith(matchingInput)) {
                          possibilities.get(jumpType).add(peptideKey);
                          types.get(jumpType).add(Type.PEPTIDE);
                        } else if (peptideKey.toLowerCase().contains(matchingInput)) {
                          secondaryCandidates.add(peptideKey);
                        }
                      }
                    }

                    PeptideMatchesIterator peptideMatchesIterator =
                        identification.getPeptideMatchesIterator(
                            secondaryCandidates,
                            null,
                            false,
                            null,
                            null); // @TODO: waiting handler?

                    while (peptideMatchesIterator.hasNext()) {

                      try {
                        PeptideMatch peptideMatch = peptideMatchesIterator.next();
                        String peptideKey = peptideMatch.getKey();
                        ArrayList<String> proteins =
                            peptideMatch.getTheoreticPeptide().getParentProteinsNoRemapping();
                        if (proteins != null) {
                          for (String protein : proteins) {
                            if (!ProteinMatch.isDecoy(protein)) {
                              possibilities.get(jumpType).add(peptideKey);
                              types.get(jumpType).add(Type.PEPTIDE);
                              break;
                            }
                          }
                        }
                      } catch (Exception e) {
                        peptideShakerGUI.catchException(e);
                        return;
                      }
                    }
                  }
                } else {
                  for (String spectrumTitle : spectrumFactory.getSpectrumTitles(spectrumfile)) {
                    String spectrumKey = Spectrum.getSpectrumKey(spectrumfile, spectrumTitle);
                    if (spectrumKey.toLowerCase().contains(input)) {
                      possibilities.get(jumpType).add(spectrumKey);
                      types.get(jumpType).add(Type.SPECTRUM);
                    } else {
                      try {
                        Precursor precursor = spectrumFactory.getPrecursor(spectrumKey);
                        doubleString = precursor.getMz() + "";
                        if (doubleString.startsWith(input)) {
                          possibilities.get(jumpType).add(spectrumKey);
                          types.get(jumpType).add(Type.SPECTRUM);
                        } else {
                          doubleString = precursor.getRt() + "";
                          if (doubleString.startsWith(input)) {
                            possibilities.get(jumpType).add(spectrumKey);
                            types.get(jumpType).add(Type.SPECTRUM);
                          }
                        }
                      } catch (Exception e) {
                        e.printStackTrace();
                      }
                    }
                  }
                }

                if (possibilities.get(jumpType).size() > 0) {

                  if (possibilities.get(jumpType).size() > 1) {
                    previousButton.setEnabled(true);
                    nextButton.setEnabled(true);
                  } else { // possibilities.size() == 1
                    previousButton.setEnabled(false);
                    nextButton.setEnabled(false);
                  }

                  updateSelectionInTab();
                } else {
                  previousButton.setEnabled(false);
                  nextButton.setEnabled(false);

                  if (!input.equalsIgnoreCase(welcomeText.get(jumpType))) {
                    indexLabel.setText("(no matches)");
                  } else {
                    indexLabel.setText("");
                  }
                }

                peptideShakerGUI.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
                inputTxt.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));

              } else {
                indexLabel.setText("");
                previousButton.setEnabled(false);
                nextButton.setEnabled(false);
                inputTxt.setText(welcomeText.get(jumpType));
                inputTxt.selectAll();
              }
            }

            lastLabel.put(jumpType, indexLabel.getText());

            // gui updated, reset the counter
            keyPressedCounter = 0;
          } else {
            // gui not updated, decrease the counter
            keyPressedCounter--;
          }
        } catch (Exception e) {
          peptideShakerGUI.catchException(e);
        }
      }
    }.start();
  } // GEN-LAST:event_inputTxtKeyReleased

  /**
   * Display the previous match in the list.
   *
   * @param evt the action event
   */
  private void previousButtonActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_previousButtonActionPerformed
    if (currentSelection.get(jumpType) == 0) {
      currentSelection.put(jumpType, possibilities.get(jumpType).size() - 1);
    } else {
      currentSelection.put(jumpType, currentSelection.get(jumpType) - 1);
    }
    updateSelectionInTab();
  } // GEN-LAST:event_previousButtonActionPerformed

  /**
   * Display the next match in the list.
   *
   * @param evt the action event
   */
  private void nextButtonActionPerformed(
      java.awt.event.ActionEvent evt) { // GEN-FIRST:event_nextButtonActionPerformed
    if (currentSelection.get(jumpType) == possibilities.get(jumpType).size() - 1) {
      currentSelection.put(jumpType, 0);
    } else {
      currentSelection.put(jumpType, currentSelection.get(jumpType) + 1);
    }
    updateSelectionInTab();
  } // GEN-LAST:event_nextButtonActionPerformed

  /**
   * Select all text in the search field.
   *
   * @param evt the mouse event
   */
  private void inputTxtMouseReleased(
      java.awt.event.MouseEvent evt) { // GEN-FIRST:event_inputTxtMouseReleased
    if (inputTxt.getText().equals(welcomeText.get(jumpType))) {
      inputTxt.selectAll();
    }
  } // GEN-LAST:event_inputTxtMouseReleased

  /**
   * Change the icon to a hand icon.
   *
   * @param evt the mouse event
   */
  private void previousButtonMouseEntered(
      java.awt.event.MouseEvent evt) { // GEN-FIRST:event_previousButtonMouseEntered
    if (previousButton.isEnabled()) {
      this.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
    }
  } // GEN-LAST:event_previousButtonMouseEntered

  /**
   * Change the icon back to the default icon.
   *
   * @param evt the mouse event
   */
  private void previousButtonMouseExited(
      java.awt.event.MouseEvent evt) { // GEN-FIRST:event_previousButtonMouseExited
    this.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
  } // GEN-LAST:event_previousButtonMouseExited

  /**
   * Change the icon back to the default icon.
   *
   * @param evt the mouse event
   */
  private void nextButtonMouseExited(
      java.awt.event.MouseEvent evt) { // GEN-FIRST:event_nextButtonMouseExited
    this.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
  } // GEN-LAST:event_nextButtonMouseExited

  /**
   * Change the icon to a hand icon.
   *
   * @param evt the mouse event
   */
  private void nextButtonMouseEntered(
      java.awt.event.MouseEvent evt) { // GEN-FIRST:event_nextButtonMouseEntered
    if (nextButton.isEnabled()) {
      this.setCursor(new java.awt.Cursor(java.awt.Cursor.HAND_CURSOR));
    }
  } // GEN-LAST:event_nextButtonMouseEntered
  // Variables declaration - do not modify//GEN-BEGIN:variables
  private javax.swing.JLabel findJLabel;
  private javax.swing.JLabel indexLabel;
  private javax.swing.JTextField inputTxt;
  private javax.swing.JButton nextButton;
  private javax.swing.JButton previousButton;
  // End of variables declaration//GEN-END:variables

  @Override
  public void setEnabled(boolean enabled) {

    inputTxt.setEnabled(enabled);
    indexLabel.setEnabled(enabled);

    if (possibilities.size() > 0 && enabled) {
      previousButton.setEnabled(true);
      nextButton.setEnabled(true);
    } else {
      previousButton.setEnabled(false);
      nextButton.setEnabled(false);
    }
  }

  /**
   * Changes the type of jumpToPanel.
   *
   * @param jumpType the new type of jump to panel
   */
  public void setType(JumpType jumpType) {
    this.jumpType = jumpType;
    if (lastInput.get(jumpType) != null && !lastInput.get(jumpType).equals("")) {
      inputTxt.setText(lastInput.get(jumpType));
      indexLabel.setText(lastLabel.get(jumpType));
    } else {
      inputTxt.setText(welcomeText.get(jumpType));
      indexLabel.setText("");
    }
  }

  /**
   * Sets the spectrum file inspected.
   *
   * @param spectrumFile the name of the spectrum file inspected
   */
  public void setSpectrumFile(String spectrumFile) {
    this.spectrumfile = spectrumFile;
  }
}
コード例 #4
0
  /**
   * Fills the PSM specific map.
   *
   * @param inputMap The input map
   * @param waitingHandler the handler displaying feedback to the user
   * @param shotgunProtocol information about the protocol
   * @param identificationParameters the identification parameters
   * @throws java.sql.SQLException exception thrown whenever an error occurred while interacting
   *     with the back-end database
   * @throws java.io.IOException exception thrown whenever an error occurred while reading an
   *     external file
   * @throws java.lang.ClassNotFoundException exception thrown whenever an error occurred while
   *     deserializing an object
   * @throws java.lang.InterruptedException exception thrown whenever a threading error occurred
   * @throws uk.ac.ebi.jmzml.xml.io.MzMLUnmarshallerException exception thrown whenever an error
   *     occurred while reading an mzML file
   */
  public void selectBestHitAndFillPsmMap(
      InputMap inputMap,
      WaitingHandler waitingHandler,
      ShotgunProtocol shotgunProtocol,
      IdentificationParameters identificationParameters)
      throws SQLException, IOException, ClassNotFoundException, InterruptedException,
          MzMLUnmarshallerException {

    waitingHandler.setSecondaryProgressCounterIndeterminate(false);
    waitingHandler.setMaxSecondaryProgressCounter(identification.getSpectrumIdentificationSize());

    PeptideSpectrumAnnotator spectrumAnnotator = new PeptideSpectrumAnnotator();
    boolean multiSE = inputMap.isMultipleAlgorithms();

    SequenceMatchingPreferences sequenceMatchingPreferences =
        identificationParameters.getSequenceMatchingPreferences();
    AnnotationSettings annotationPreferences = identificationParameters.getAnnotationPreferences();

    PeptideAssumptionFilter idFilter = identificationParameters.getPeptideAssumptionFilter();

    // Keep a map of the spectrum keys grouped by peptide
    HashMap<String, ArrayList<String>> orderedPsmMap = null;
    if (MemoryConsumptionStatus.memoryUsed() < 0.8) {
      orderedPsmMap =
          new HashMap<String, ArrayList<String>>(
              identification.getSpectrumIdentificationMap().size());
    }

    PSParameter psParameter = new PSParameter();

    for (String spectrumFileName : identification.getSpectrumFiles()) {

      HashMap<String, ArrayList<String>> keysMap = null;
      if (orderedPsmMap != null) {
        keysMap = new HashMap<String, ArrayList<String>>();
      }

      PsmIterator psmIterator =
          identification.getPsmIterator(spectrumFileName, null, true, waitingHandler);

      while (psmIterator.hasNext()) {

        SpectrumMatch advocateMatch = psmIterator.next();
        String spectrumKey = advocateMatch.getKey();

        // map of the peptide first hits for this spectrum: score -> max protein count -> max search
        // engine votes -> amino acids annotated -> min mass deviation -> peptide sequence
        HashMap<
                Double,
                HashMap<
                    Integer,
                    HashMap<
                        Integer,
                        HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>>
            peptideAssumptions =
                new HashMap<
                    Double,
                    HashMap<
                        Integer,
                        HashMap<
                            Integer,
                            HashMap<
                                Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>>();

        // map of the tag first hits: score -> assumptions
        HashMap<Double, ArrayList<TagAssumption>> tagAssumptions =
            new HashMap<Double, ArrayList<TagAssumption>>();

        ArrayList<String> identifications = new ArrayList<String>();

        HashMap<Integer, HashMap<Double, ArrayList<SpectrumIdentificationAssumption>>> assumptions =
            identification.getAssumptions(spectrumKey);

        for (int searchEngine1 : assumptions.keySet()) {

          HashMap<Double, ArrayList<SpectrumIdentificationAssumption>> advocate1Map =
              assumptions.get(searchEngine1);

          double bestEvalue = Collections.min(advocate1Map.keySet());

          for (SpectrumIdentificationAssumption assumption1 : advocate1Map.get(bestEvalue)) {

            if (assumption1 instanceof PeptideAssumption) {

              PeptideAssumption peptideAssumption1 = (PeptideAssumption) assumption1;
              String id = peptideAssumption1.getPeptide().getKey();

              if (!identifications.contains(id)) {

                psParameter = (PSParameter) peptideAssumption1.getUrParam(psParameter);
                double p;

                if (multiSE && sequenceFactory.concatenatedTargetDecoy()) {
                  p = psParameter.getSearchEngineProbability();
                } else {
                  p = peptideAssumption1.getScore();
                }

                int nSE = 1;
                int proteinMax = 1;
                for (String protein :
                    peptideAssumption1
                        .getPeptide()
                        .getParentProteins(sequenceMatchingPreferences)) {
                  Integer tempCount = proteinCount.get(protein);
                  if (tempCount != null && tempCount > proteinMax) {
                    proteinMax = tempCount;
                  }
                }

                for (int searchEngine2 : assumptions.keySet()) {

                  if (searchEngine1 != searchEngine2) {

                    HashMap<Double, ArrayList<SpectrumIdentificationAssumption>> advocate2Map =
                        assumptions.get(searchEngine2);

                    boolean found = false;
                    ArrayList<Double> eValues2 = new ArrayList<Double>(advocate2Map.keySet());
                    Collections.sort(eValues2);

                    for (double eValue2 : eValues2) {
                      for (SpectrumIdentificationAssumption assumption2 :
                          advocate2Map.get(eValue2)) {

                        if (assumption2 instanceof PeptideAssumption) {

                          PeptideAssumption peptideAssumption2 = (PeptideAssumption) assumption2;

                          if (peptideAssumption1
                              .getPeptide()
                              .isSameSequenceAndModificationStatus(
                                  peptideAssumption2.getPeptide(), sequenceMatchingPreferences)) {
                            PSParameter psParameter2 =
                                (PSParameter) peptideAssumption2.getUrParam(psParameter);
                            p = p * psParameter2.getSearchEngineProbability();
                            nSE++;
                            found = true;
                            break;
                          }
                        }
                      }
                      if (found) {
                        break;
                      }
                    }
                  }
                }

                identifications.add(id);

                HashMap<
                        Integer,
                        HashMap<
                            Integer,
                            HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>
                    pMap = peptideAssumptions.get(p);
                if (pMap == null) {
                  pMap =
                      new HashMap<
                          Integer,
                          HashMap<
                              Integer,
                              HashMap<
                                  Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>(
                          advocate1Map.size());
                  peptideAssumptions.put(p, pMap);
                }

                HashMap<
                        Integer,
                        HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>
                    proteinMaxMap = pMap.get(proteinMax);
                if (proteinMaxMap == null) {
                  proteinMaxMap =
                      new HashMap<
                          Integer,
                          HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>(1);
                  pMap.put(proteinMax, proteinMaxMap);
                }

                HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>> nSeMap =
                    proteinMaxMap.get(nSE);
                if (nSeMap == null) {
                  nSeMap =
                      new HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>(1);
                  proteinMaxMap.put(nSE, nSeMap);
                  HashMap<Double, HashMap<String, PeptideAssumption>> coverageMap =
                      new HashMap<Double, HashMap<String, PeptideAssumption>>(1);
                  nSeMap.put(-1, coverageMap);
                  HashMap<String, PeptideAssumption> assumptionMap =
                      new HashMap<String, PeptideAssumption>(1);
                  coverageMap.put(-1.0, assumptionMap);
                  assumptionMap.put(
                      peptideAssumption1.getPeptide().getSequenceWithLowerCasePtms(),
                      peptideAssumption1);
                } else {
                  MSnSpectrum spectrum = (MSnSpectrum) spectrumFactory.getSpectrum(spectrumKey);

                  HashMap<Double, HashMap<String, PeptideAssumption>> coverageMap = nSeMap.get(-1);
                  if (coverageMap != null) {
                    HashMap<String, PeptideAssumption> assumptionMap = coverageMap.get(-1.0);
                    for (PeptideAssumption tempAssumption :
                        assumptionMap.values()) { // There should be only one
                      Peptide peptide = tempAssumption.getPeptide();
                      SpecificAnnotationSettings specificAnnotationPreferences =
                          annotationPreferences.getSpecificAnnotationPreferences(
                              spectrum.getSpectrumKey(),
                              tempAssumption,
                              identificationParameters.getSequenceMatchingPreferences(),
                              identificationParameters
                                  .getPtmScoringPreferences()
                                  .getSequenceMatchingPreferences());
                      HashMap<Integer, ArrayList<IonMatch>> coveredAminoAcids =
                          spectrumAnnotator.getCoveredAminoAcids(
                              annotationPreferences,
                              specificAnnotationPreferences,
                              (MSnSpectrum) spectrum,
                              peptide);
                      int nIons = coveredAminoAcids.size();
                      nSeMap.put(nIons, coverageMap);
                    }
                    nSeMap.remove(-1);
                  }

                  Peptide peptide = peptideAssumption1.getPeptide();
                  SpecificAnnotationSettings specificAnnotationPreferences =
                      annotationPreferences.getSpecificAnnotationPreferences(
                          spectrum.getSpectrumKey(),
                          peptideAssumption1,
                          identificationParameters.getSequenceMatchingPreferences(),
                          identificationParameters
                              .getPtmScoringPreferences()
                              .getSequenceMatchingPreferences());
                  HashMap<Integer, ArrayList<IonMatch>> coveredAminoAcids =
                      spectrumAnnotator.getCoveredAminoAcids(
                          annotationPreferences,
                          specificAnnotationPreferences,
                          (MSnSpectrum) spectrum,
                          peptide);
                  int nIons = coveredAminoAcids.size();

                  coverageMap = nSeMap.get(nIons);
                  if (coverageMap == null) {
                    coverageMap = new HashMap<Double, HashMap<String, PeptideAssumption>>(1);
                    HashMap<String, PeptideAssumption> assumptionMap =
                        new HashMap<String, PeptideAssumption>(1);
                    assumptionMap.put(
                        peptideAssumption1.getPeptide().getSequenceWithLowerCasePtms(),
                        peptideAssumption1);
                    coverageMap.put(-1.0, assumptionMap);
                    nSeMap.put(nIons, coverageMap);
                  } else {
                    HashMap<String, PeptideAssumption> assumptionMap = coverageMap.get(-1.0);
                    if (assumptionMap != null) {
                      for (PeptideAssumption tempAssumption :
                          assumptionMap.values()) { // There should be only one
                        double massError =
                            Math.abs(
                                tempAssumption.getDeltaMass(
                                    spectrum.getPrecursor().getMz(),
                                    shotgunProtocol.isMs1ResolutionPpm()));
                        coverageMap.put(massError, assumptionMap);
                      }
                      coverageMap.remove(-1.0);
                    }

                    double massError =
                        Math.abs(
                            peptideAssumption1.getDeltaMass(
                                spectrum.getPrecursor().getMz(),
                                shotgunProtocol.isMs1ResolutionPpm()));
                    assumptionMap = coverageMap.get(massError);
                    if (assumptionMap == null) {
                      assumptionMap = new HashMap<String, PeptideAssumption>(1);
                      coverageMap.put(massError, assumptionMap);
                    }
                    assumptionMap.put(
                        peptideAssumption1.getPeptide().getSequenceWithLowerCasePtms(),
                        peptideAssumption1);
                  }
                }
              }
            } else if (assumption1 instanceof TagAssumption) {
              TagAssumption tagAssumption = (TagAssumption) assumption1;
              ArrayList<TagAssumption> assumptionList = tagAssumptions.get(bestEvalue);
              if (assumptionList == null) {
                assumptionList = new ArrayList<TagAssumption>();
                tagAssumptions.put(bestEvalue, assumptionList);
              }
              assumptionList.add(tagAssumption);
            }
          }
        }

        SpectrumMatch spectrumMatch = new SpectrumMatch(spectrumKey);
        if (!peptideAssumptions.isEmpty()) {

          PeptideAssumption bestPeptideAssumption = null;
          ArrayList<Double> ps = new ArrayList<Double>(peptideAssumptions.keySet());
          Collections.sort(ps);
          double retainedP = 0;

          for (double p : ps) {

            retainedP = p;
            HashMap<
                    Integer,
                    HashMap<
                        Integer,
                        HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>
                pMap = peptideAssumptions.get(p);
            ArrayList<Integer> proteinMaxs = new ArrayList<Integer>(pMap.keySet());
            Collections.sort(proteinMaxs, Collections.reverseOrder());

            for (int proteinMax : proteinMaxs) {

              HashMap<
                      Integer,
                      HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>
                  proteinMaxMap = pMap.get(proteinMax);
              ArrayList<Integer> nSEs = new ArrayList<Integer>(proteinMaxMap.keySet());
              Collections.sort(nSEs, Collections.reverseOrder());

              for (int nSE : nSEs) {

                HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>> nSeMap =
                    proteinMaxMap.get(nSE);
                ArrayList<Integer> coverages = new ArrayList<Integer>(nSeMap.keySet());
                Collections.sort(coverages, Collections.reverseOrder());

                for (Integer coverage : coverages) {

                  HashMap<Double, HashMap<String, PeptideAssumption>> coverageMap =
                      nSeMap.get(coverage);
                  ArrayList<Double> minErrors = new ArrayList<Double>(coverageMap.keySet());
                  Collections.sort(minErrors);

                  for (double minError : minErrors) {

                    HashMap<String, PeptideAssumption> bestPeptideAssumptions =
                        coverageMap.get(minError);
                    ArrayList<String> sequences =
                        new ArrayList<String>(bestPeptideAssumptions.keySet());
                    Collections.sort(sequences);

                    for (String sequence : sequences) {
                      PeptideAssumption peptideAssumption = bestPeptideAssumptions.get(sequence);
                      if (idFilter.validateProteins(
                          peptideAssumption.getPeptide(), sequenceMatchingPreferences)) {
                        bestPeptideAssumption = peptideAssumption;
                        break;
                      }
                    }
                    if (bestPeptideAssumption != null) {
                      break;
                    }
                  }
                  if (bestPeptideAssumption != null) {
                    break;
                  }
                }
                if (bestPeptideAssumption != null) {
                  break;
                }
              }
              if (bestPeptideAssumption != null) {
                break;
              }
            }
            if (bestPeptideAssumption != null) {
              break;
            }
          }
          if (bestPeptideAssumption != null) {

            if (multiSE) {

              // try to find the most likely modification localization based on the search engine
              // results
              HashMap<PeptideAssumption, ArrayList<Double>> assumptionPEPs =
                  new HashMap<PeptideAssumption, ArrayList<Double>>();
              String bestAssumptionKey =
                  bestPeptideAssumption.getPeptide().getMatchingKey(sequenceMatchingPreferences);

              for (int searchEngine : assumptions.keySet()) {

                boolean found = false;
                HashMap<Double, ArrayList<SpectrumIdentificationAssumption>> advocateMap =
                    assumptions.get(searchEngine);
                ArrayList<Double> eValues = new ArrayList<Double>(advocateMap.keySet());
                Collections.sort(eValues);

                for (double eValue : eValues) {
                  for (SpectrumIdentificationAssumption assumption : advocateMap.get(eValue)) {

                    if (assumption instanceof PeptideAssumption) {

                      PeptideAssumption peptideAssumption = (PeptideAssumption) assumption;

                      if (peptideAssumption
                          .getPeptide()
                          .getMatchingKey(sequenceMatchingPreferences)
                          .equals(bestAssumptionKey)) {

                        found = true;
                        boolean found2 = false;

                        for (PeptideAssumption assumption1 : assumptionPEPs.keySet()) {
                          if (assumption1
                              .getPeptide()
                              .sameModificationsAs(peptideAssumption.getPeptide())) {
                            found2 = true;
                            psParameter = (PSParameter) assumption.getUrParam(psParameter);
                            ArrayList<Double> peps = assumptionPEPs.get(assumption1);
                            peps.add(psParameter.getSearchEngineProbability());
                            break;
                          }
                        }

                        if (!found2) {
                          ArrayList<Double> peps = new ArrayList<Double>(1);
                          assumptionPEPs.put(peptideAssumption, peps);
                          psParameter = (PSParameter) assumption.getUrParam(psParameter);
                          peps.add(psParameter.getSearchEngineProbability());
                        }
                      }
                    }
                  }

                  if (found) {
                    break;
                  }
                }
              }

              Double bestSeP = null;
              int nSe = -1;

              for (PeptideAssumption peptideAssumption : assumptionPEPs.keySet()) {

                ArrayList<Double> peps = assumptionPEPs.get(peptideAssumption);
                Double sep = Collections.min(peps);

                if (bestSeP == null || bestSeP > sep) {
                  bestSeP = sep;
                  nSe = peps.size();
                  bestPeptideAssumption = peptideAssumption;
                } else if (peps.size() > nSe) {
                  if (sep != null && (Math.abs(sep - bestSeP) <= 1e-10)) {
                    nSe = peps.size();
                    bestPeptideAssumption = peptideAssumption;
                  }
                }
              }
            }

            // create a PeptideShaker match based on the best search engine match
            Peptide sePeptide = bestPeptideAssumption.getPeptide();
            ArrayList<String> psProteins =
                new ArrayList<String>(sePeptide.getParentProteins(sequenceMatchingPreferences));
            ArrayList<ModificationMatch> psModificationMatches = null;
            if (sePeptide.isModified()) {
              psModificationMatches =
                  new ArrayList<ModificationMatch>(sePeptide.getNModifications());
              for (ModificationMatch seModMatch : sePeptide.getModificationMatches()) {
                psModificationMatches.add(
                    new ModificationMatch(
                        seModMatch.getTheoreticPtm(),
                        seModMatch.isVariable(),
                        seModMatch.getModificationSite()));
              }
            }

            Peptide psPeptide = new Peptide(sePeptide.getSequence(), psModificationMatches);
            psPeptide.setParentProteins(psProteins);
            PeptideAssumption psAssumption =
                new PeptideAssumption(
                    psPeptide,
                    1,
                    Advocate.peptideShaker.getIndex(),
                    bestPeptideAssumption.getIdentificationCharge(),
                    retainedP);

            spectrumMatch.setBestPeptideAssumption(psAssumption);

            if (orderedPsmMap != null) {
              String peptideKey = psPeptide.getMatchingKey(sequenceMatchingPreferences);
              ArrayList<String> spectrumKeys = keysMap.get(peptideKey);
              if (spectrumKeys == null) {
                spectrumKeys = new ArrayList<String>();
                keysMap.put(peptideKey, spectrumKeys);
              }
              spectrumKeys.add(spectrumKey);
            }

            psParameter = new PSParameter();
            psParameter.setSpectrumProbabilityScore(retainedP);

            PSParameter matchParameter =
                (PSParameter) bestPeptideAssumption.getUrParam(psParameter);
            psParameter.setSearchEngineProbability(matchParameter.getSearchEngineProbability());
            psParameter.setAlgorithmDeltaPEP(matchParameter.getAlgorithmDeltaPEP());
            psParameter.setDeltaPEP(matchParameter.getDeltaPEP());

            matchesValidator
                .getPsmMap()
                .addPoint(
                    psParameter.getPsmProbabilityScore(),
                    spectrumMatch,
                    sequenceMatchingPreferences);
            psParameter.setSpecificMapKey(
                spectrumMatch.getBestPeptideAssumption().getIdentificationCharge().value + "");
            identification.addSpectrumMatchParameter(spectrumKey, psParameter);
            identification.updateSpectrumMatch(spectrumMatch);
          }
        }
        if (!tagAssumptions.isEmpty()) {
          ArrayList<Double> evalues = new ArrayList<Double>(tagAssumptions.keySet());
          Double bestEvalue = Collections.min(evalues);
          TagAssumption bestAssumption = tagAssumptions.get(bestEvalue).get(0);
          spectrumMatch.setBestTagAssumption(bestAssumption);
          identification.updateSpectrumMatch(spectrumMatch);
          if (spectrumMatch.getBestPeptideAssumption() == null) {
            psParameter = new PSParameter();
            if (!multiSE) {
              psParameter.setSpectrumProbabilityScore(bestEvalue);
            }
            PSParameter matchParameter = (PSParameter) bestAssumption.getUrParam(psParameter);
            psParameter.setSearchEngineProbability(matchParameter.getSearchEngineProbability());
            psParameter.setAlgorithmDeltaPEP(matchParameter.getAlgorithmDeltaPEP());
            psParameter.setDeltaPEP(matchParameter.getDeltaPEP());
            psParameter.setSpecificMapKey(
                spectrumMatch.getBestTagAssumption().getIdentificationCharge().value + "");
            identification.addSpectrumMatchParameter(spectrumKey, psParameter);
          }
        }
        waitingHandler.increaseSecondaryProgressCounter();
        if (waitingHandler.isRunCanceled()) {
          return;
        }
      }

      if (orderedPsmMap != null) {
        ArrayList<String> orderedKeys =
            new ArrayList<String>(
                identification.getSpectrumIdentification(spectrumFileName).size());
        for (ArrayList<String> keys : keysMap.values()) {
          orderedKeys.addAll(keys);
        }
        orderedPsmMap.put(spectrumFileName, orderedKeys);

        if (MemoryConsumptionStatus.memoryUsed() > 0.9) {
          orderedPsmMap = null;
        }
      }
    }

    if (orderedPsmMap != null) {
      metrics.setOrderedSpectrumKeys(orderedPsmMap);
    }

    // the protein count map is no longer needed
    proteinCount.clear();

    waitingHandler.setSecondaryProgressCounterIndeterminate(true);
  }
コード例 #5
0
  /**
   * Selects a first hit in a list of equally scoring peptide matches. The selection is made based
   * on: 1 - The occurrence of the protein detection as given in the proteinCount map 2 - The
   * sequence coverage by fragment ions 3 - The precursor mass error.
   *
   * <p>If no best hit is found, the first one sorted alphabetically is retained.
   *
   * @param spectrumKey the key of the spectrum
   * @param firstHits list of equally scoring peptide matches
   * @param proteinCount map of the number of peptides for every protein
   * @param sequenceMatchingPreferences the sequence matching preferences
   * @param shotgunProtocol the shotgun protocol
   * @param identificationParameters the identification parameters
   * @param spectrumAnnotator the spectrum annotator to use
   * @return a first hit from the list of equally scoring peptide matches
   * @throws IOException exception thrown whenever an IO exception occurred while remapping the
   *     proteins or getting the spectrum
   * @throws InterruptedException exception thrown whenever an interrupted exception occurred while
   *     remapping the proteins or getting the spectrum
   * @throws SQLException exception thrown whenever an SQL exception occurred while interacting with
   *     the protein tree
   * @throws ClassNotFoundException exception thrown whenever an exception occurred while
   *     deserializing an object
   * @throws MzMLUnmarshallerException exception thrown whenever an exception occurred while reading
   *     an mzML file
   */
  public static PeptideAssumption getBestHit(
      String spectrumKey,
      ArrayList<PeptideAssumption> firstHits,
      HashMap<String, Integer> proteinCount,
      SequenceMatchingPreferences sequenceMatchingPreferences,
      ShotgunProtocol shotgunProtocol,
      IdentificationParameters identificationParameters,
      PeptideSpectrumAnnotator spectrumAnnotator)
      throws IOException, InterruptedException, SQLException, ClassNotFoundException,
          MzMLUnmarshallerException {

    if (firstHits.size() == 1) {
      return firstHits.get(0);
    }

    Integer maxProteins = 0;
    ArrayList<PeptideAssumption> bestPeptideAssumptions =
        new ArrayList<PeptideAssumption>(firstHits.size());

    for (PeptideAssumption peptideAssumption : firstHits) {
      for (String accession :
          peptideAssumption.getPeptide().getParentProteins(sequenceMatchingPreferences)) {
        Integer count = proteinCount.get(accession);
        if (count != null) {
          if (count > maxProteins) {
            maxProteins = count;
            bestPeptideAssumptions.clear();
            bestPeptideAssumptions.add(peptideAssumption);
          } else if (count.equals(maxProteins)) {
            bestPeptideAssumptions.add(peptideAssumption);
          }
        }
      }
    }

    if (bestPeptideAssumptions.size() == 1) {
      return bestPeptideAssumptions.get(0);
    } else if (!bestPeptideAssumptions.isEmpty()) {
      firstHits = bestPeptideAssumptions;
      bestPeptideAssumptions = new ArrayList<PeptideAssumption>(firstHits.size());
    }

    MSnSpectrum spectrum = (MSnSpectrum) SpectrumFactory.getInstance().getSpectrum(spectrumKey);
    int maxCoveredAminoAcids = 0;
    AnnotationSettings annotationPreferences = identificationParameters.getAnnotationPreferences();

    for (PeptideAssumption peptideAssumption : firstHits) {
      Peptide peptide = peptideAssumption.getPeptide();
      SpecificAnnotationSettings specificAnnotationPreferences =
          annotationPreferences.getSpecificAnnotationPreferences(
              spectrum.getSpectrumKey(),
              peptideAssumption,
              identificationParameters.getSequenceMatchingPreferences(),
              identificationParameters.getPtmScoringPreferences().getSequenceMatchingPreferences());
      HashMap<Integer, ArrayList<IonMatch>> coveredAminoAcids =
          spectrumAnnotator.getCoveredAminoAcids(
              annotationPreferences,
              specificAnnotationPreferences,
              (MSnSpectrum) spectrum,
              peptide);
      int nAas = coveredAminoAcids.size();
      if (nAas > maxCoveredAminoAcids) {
        maxCoveredAminoAcids = nAas;
        bestPeptideAssumptions.clear();
        bestPeptideAssumptions.add(peptideAssumption);
      } else if (nAas == maxCoveredAminoAcids) {
        bestPeptideAssumptions.add(peptideAssumption);
      }
    }

    if (bestPeptideAssumptions.size() == 1) {
      return bestPeptideAssumptions.get(0);
    } else if (!bestPeptideAssumptions.isEmpty()) {
      firstHits = bestPeptideAssumptions;
      bestPeptideAssumptions = new ArrayList<PeptideAssumption>(firstHits.size());
    }

    double minMassError = identificationParameters.getPeptideAssumptionFilter().getMaxMzDeviation();
    if (minMassError == -1.0) {
      minMassError = identificationParameters.getSearchParameters().getPrecursorAccuracy();
    }

    for (PeptideAssumption peptideAssumption : firstHits) {
      double massError =
          Math.abs(
              peptideAssumption.getDeltaMass(
                  spectrum.getPrecursor().getMz(), shotgunProtocol.isMs1ResolutionPpm()));
      if (massError < minMassError) {
        minMassError = massError;
        bestPeptideAssumptions.clear();
        bestPeptideAssumptions.add(peptideAssumption);
      } else if (massError == minMassError) {
        bestPeptideAssumptions.add(peptideAssumption);
      }
    }

    if (bestPeptideAssumptions.size() == 1) {
      return bestPeptideAssumptions.get(0);
    } else if (bestPeptideAssumptions.isEmpty()) {
      bestPeptideAssumptions = firstHits;
    }

    HashMap<String, PeptideAssumption> sequenceToPeptideAssumptionsMap =
        new HashMap<String, PeptideAssumption>(bestPeptideAssumptions.size());
    for (PeptideAssumption peptideAssumption : bestPeptideAssumptions) {
      sequenceToPeptideAssumptionsMap.put(
          peptideAssumption.getPeptide().getSequence(), peptideAssumption);
    }

    ArrayList<String> sequences = new ArrayList<String>(sequenceToPeptideAssumptionsMap.keySet());
    Collections.sort(sequences);
    return sequenceToPeptideAssumptionsMap.get(sequences.get(0));
  }
コード例 #6
0
/**
 * This class contains the method for PSM best hit selection.
 *
 * @author Marc Vaudel
 */
public class BestMatchSelection {

  /** The sequence factory. */
  private SequenceFactory sequenceFactory = SequenceFactory.getInstance();
  /** The spectrum factory. */
  private SpectrumFactory spectrumFactory = SpectrumFactory.getInstance();
  /**
   * Map indicating how often a protein was found in a search engine first hit whenever this protein
   * was found more than one time.
   */
  private HashMap<String, Integer> proteinCount = new HashMap<String, Integer>();
  /** The identification object. */
  private Identification identification;
  /** The validator which will take care of the matches validation. */
  private MatchesValidator matchesValidator;
  /** Metrics to be picked when loading the identification. */
  private Metrics metrics = new Metrics();

  /**
   * Constructor.
   *
   * @param identification the identification object where to get the matches from
   * @param proteinCount a map of proteins found multiple times
   * @param matchesValidator the matches validator
   * @param metrics the object where to store dataset metrics
   */
  public BestMatchSelection(
      Identification identification,
      HashMap<String, Integer> proteinCount,
      MatchesValidator matchesValidator,
      Metrics metrics) {
    this.identification = identification;
    this.proteinCount = proteinCount;
    this.matchesValidator = matchesValidator;
    this.metrics = metrics;
  }

  /**
   * Fills the PSM specific map.
   *
   * @param inputMap The input map
   * @param waitingHandler the handler displaying feedback to the user
   * @param shotgunProtocol information about the protocol
   * @param identificationParameters the identification parameters
   * @throws java.sql.SQLException exception thrown whenever an error occurred while interacting
   *     with the back-end database
   * @throws java.io.IOException exception thrown whenever an error occurred while reading an
   *     external file
   * @throws java.lang.ClassNotFoundException exception thrown whenever an error occurred while
   *     deserializing an object
   * @throws java.lang.InterruptedException exception thrown whenever a threading error occurred
   * @throws uk.ac.ebi.jmzml.xml.io.MzMLUnmarshallerException exception thrown whenever an error
   *     occurred while reading an mzML file
   */
  public void selectBestHitAndFillPsmMap(
      InputMap inputMap,
      WaitingHandler waitingHandler,
      ShotgunProtocol shotgunProtocol,
      IdentificationParameters identificationParameters)
      throws SQLException, IOException, ClassNotFoundException, InterruptedException,
          MzMLUnmarshallerException {

    waitingHandler.setSecondaryProgressCounterIndeterminate(false);
    waitingHandler.setMaxSecondaryProgressCounter(identification.getSpectrumIdentificationSize());

    PeptideSpectrumAnnotator spectrumAnnotator = new PeptideSpectrumAnnotator();
    boolean multiSE = inputMap.isMultipleAlgorithms();

    SequenceMatchingPreferences sequenceMatchingPreferences =
        identificationParameters.getSequenceMatchingPreferences();
    AnnotationSettings annotationPreferences = identificationParameters.getAnnotationPreferences();

    PeptideAssumptionFilter idFilter = identificationParameters.getPeptideAssumptionFilter();

    // Keep a map of the spectrum keys grouped by peptide
    HashMap<String, ArrayList<String>> orderedPsmMap = null;
    if (MemoryConsumptionStatus.memoryUsed() < 0.8) {
      orderedPsmMap =
          new HashMap<String, ArrayList<String>>(
              identification.getSpectrumIdentificationMap().size());
    }

    PSParameter psParameter = new PSParameter();

    for (String spectrumFileName : identification.getSpectrumFiles()) {

      HashMap<String, ArrayList<String>> keysMap = null;
      if (orderedPsmMap != null) {
        keysMap = new HashMap<String, ArrayList<String>>();
      }

      PsmIterator psmIterator =
          identification.getPsmIterator(spectrumFileName, null, true, waitingHandler);

      while (psmIterator.hasNext()) {

        SpectrumMatch advocateMatch = psmIterator.next();
        String spectrumKey = advocateMatch.getKey();

        // map of the peptide first hits for this spectrum: score -> max protein count -> max search
        // engine votes -> amino acids annotated -> min mass deviation -> peptide sequence
        HashMap<
                Double,
                HashMap<
                    Integer,
                    HashMap<
                        Integer,
                        HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>>
            peptideAssumptions =
                new HashMap<
                    Double,
                    HashMap<
                        Integer,
                        HashMap<
                            Integer,
                            HashMap<
                                Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>>();

        // map of the tag first hits: score -> assumptions
        HashMap<Double, ArrayList<TagAssumption>> tagAssumptions =
            new HashMap<Double, ArrayList<TagAssumption>>();

        ArrayList<String> identifications = new ArrayList<String>();

        HashMap<Integer, HashMap<Double, ArrayList<SpectrumIdentificationAssumption>>> assumptions =
            identification.getAssumptions(spectrumKey);

        for (int searchEngine1 : assumptions.keySet()) {

          HashMap<Double, ArrayList<SpectrumIdentificationAssumption>> advocate1Map =
              assumptions.get(searchEngine1);

          double bestEvalue = Collections.min(advocate1Map.keySet());

          for (SpectrumIdentificationAssumption assumption1 : advocate1Map.get(bestEvalue)) {

            if (assumption1 instanceof PeptideAssumption) {

              PeptideAssumption peptideAssumption1 = (PeptideAssumption) assumption1;
              String id = peptideAssumption1.getPeptide().getKey();

              if (!identifications.contains(id)) {

                psParameter = (PSParameter) peptideAssumption1.getUrParam(psParameter);
                double p;

                if (multiSE && sequenceFactory.concatenatedTargetDecoy()) {
                  p = psParameter.getSearchEngineProbability();
                } else {
                  p = peptideAssumption1.getScore();
                }

                int nSE = 1;
                int proteinMax = 1;
                for (String protein :
                    peptideAssumption1
                        .getPeptide()
                        .getParentProteins(sequenceMatchingPreferences)) {
                  Integer tempCount = proteinCount.get(protein);
                  if (tempCount != null && tempCount > proteinMax) {
                    proteinMax = tempCount;
                  }
                }

                for (int searchEngine2 : assumptions.keySet()) {

                  if (searchEngine1 != searchEngine2) {

                    HashMap<Double, ArrayList<SpectrumIdentificationAssumption>> advocate2Map =
                        assumptions.get(searchEngine2);

                    boolean found = false;
                    ArrayList<Double> eValues2 = new ArrayList<Double>(advocate2Map.keySet());
                    Collections.sort(eValues2);

                    for (double eValue2 : eValues2) {
                      for (SpectrumIdentificationAssumption assumption2 :
                          advocate2Map.get(eValue2)) {

                        if (assumption2 instanceof PeptideAssumption) {

                          PeptideAssumption peptideAssumption2 = (PeptideAssumption) assumption2;

                          if (peptideAssumption1
                              .getPeptide()
                              .isSameSequenceAndModificationStatus(
                                  peptideAssumption2.getPeptide(), sequenceMatchingPreferences)) {
                            PSParameter psParameter2 =
                                (PSParameter) peptideAssumption2.getUrParam(psParameter);
                            p = p * psParameter2.getSearchEngineProbability();
                            nSE++;
                            found = true;
                            break;
                          }
                        }
                      }
                      if (found) {
                        break;
                      }
                    }
                  }
                }

                identifications.add(id);

                HashMap<
                        Integer,
                        HashMap<
                            Integer,
                            HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>
                    pMap = peptideAssumptions.get(p);
                if (pMap == null) {
                  pMap =
                      new HashMap<
                          Integer,
                          HashMap<
                              Integer,
                              HashMap<
                                  Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>(
                          advocate1Map.size());
                  peptideAssumptions.put(p, pMap);
                }

                HashMap<
                        Integer,
                        HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>
                    proteinMaxMap = pMap.get(proteinMax);
                if (proteinMaxMap == null) {
                  proteinMaxMap =
                      new HashMap<
                          Integer,
                          HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>(1);
                  pMap.put(proteinMax, proteinMaxMap);
                }

                HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>> nSeMap =
                    proteinMaxMap.get(nSE);
                if (nSeMap == null) {
                  nSeMap =
                      new HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>(1);
                  proteinMaxMap.put(nSE, nSeMap);
                  HashMap<Double, HashMap<String, PeptideAssumption>> coverageMap =
                      new HashMap<Double, HashMap<String, PeptideAssumption>>(1);
                  nSeMap.put(-1, coverageMap);
                  HashMap<String, PeptideAssumption> assumptionMap =
                      new HashMap<String, PeptideAssumption>(1);
                  coverageMap.put(-1.0, assumptionMap);
                  assumptionMap.put(
                      peptideAssumption1.getPeptide().getSequenceWithLowerCasePtms(),
                      peptideAssumption1);
                } else {
                  MSnSpectrum spectrum = (MSnSpectrum) spectrumFactory.getSpectrum(spectrumKey);

                  HashMap<Double, HashMap<String, PeptideAssumption>> coverageMap = nSeMap.get(-1);
                  if (coverageMap != null) {
                    HashMap<String, PeptideAssumption> assumptionMap = coverageMap.get(-1.0);
                    for (PeptideAssumption tempAssumption :
                        assumptionMap.values()) { // There should be only one
                      Peptide peptide = tempAssumption.getPeptide();
                      SpecificAnnotationSettings specificAnnotationPreferences =
                          annotationPreferences.getSpecificAnnotationPreferences(
                              spectrum.getSpectrumKey(),
                              tempAssumption,
                              identificationParameters.getSequenceMatchingPreferences(),
                              identificationParameters
                                  .getPtmScoringPreferences()
                                  .getSequenceMatchingPreferences());
                      HashMap<Integer, ArrayList<IonMatch>> coveredAminoAcids =
                          spectrumAnnotator.getCoveredAminoAcids(
                              annotationPreferences,
                              specificAnnotationPreferences,
                              (MSnSpectrum) spectrum,
                              peptide);
                      int nIons = coveredAminoAcids.size();
                      nSeMap.put(nIons, coverageMap);
                    }
                    nSeMap.remove(-1);
                  }

                  Peptide peptide = peptideAssumption1.getPeptide();
                  SpecificAnnotationSettings specificAnnotationPreferences =
                      annotationPreferences.getSpecificAnnotationPreferences(
                          spectrum.getSpectrumKey(),
                          peptideAssumption1,
                          identificationParameters.getSequenceMatchingPreferences(),
                          identificationParameters
                              .getPtmScoringPreferences()
                              .getSequenceMatchingPreferences());
                  HashMap<Integer, ArrayList<IonMatch>> coveredAminoAcids =
                      spectrumAnnotator.getCoveredAminoAcids(
                          annotationPreferences,
                          specificAnnotationPreferences,
                          (MSnSpectrum) spectrum,
                          peptide);
                  int nIons = coveredAminoAcids.size();

                  coverageMap = nSeMap.get(nIons);
                  if (coverageMap == null) {
                    coverageMap = new HashMap<Double, HashMap<String, PeptideAssumption>>(1);
                    HashMap<String, PeptideAssumption> assumptionMap =
                        new HashMap<String, PeptideAssumption>(1);
                    assumptionMap.put(
                        peptideAssumption1.getPeptide().getSequenceWithLowerCasePtms(),
                        peptideAssumption1);
                    coverageMap.put(-1.0, assumptionMap);
                    nSeMap.put(nIons, coverageMap);
                  } else {
                    HashMap<String, PeptideAssumption> assumptionMap = coverageMap.get(-1.0);
                    if (assumptionMap != null) {
                      for (PeptideAssumption tempAssumption :
                          assumptionMap.values()) { // There should be only one
                        double massError =
                            Math.abs(
                                tempAssumption.getDeltaMass(
                                    spectrum.getPrecursor().getMz(),
                                    shotgunProtocol.isMs1ResolutionPpm()));
                        coverageMap.put(massError, assumptionMap);
                      }
                      coverageMap.remove(-1.0);
                    }

                    double massError =
                        Math.abs(
                            peptideAssumption1.getDeltaMass(
                                spectrum.getPrecursor().getMz(),
                                shotgunProtocol.isMs1ResolutionPpm()));
                    assumptionMap = coverageMap.get(massError);
                    if (assumptionMap == null) {
                      assumptionMap = new HashMap<String, PeptideAssumption>(1);
                      coverageMap.put(massError, assumptionMap);
                    }
                    assumptionMap.put(
                        peptideAssumption1.getPeptide().getSequenceWithLowerCasePtms(),
                        peptideAssumption1);
                  }
                }
              }
            } else if (assumption1 instanceof TagAssumption) {
              TagAssumption tagAssumption = (TagAssumption) assumption1;
              ArrayList<TagAssumption> assumptionList = tagAssumptions.get(bestEvalue);
              if (assumptionList == null) {
                assumptionList = new ArrayList<TagAssumption>();
                tagAssumptions.put(bestEvalue, assumptionList);
              }
              assumptionList.add(tagAssumption);
            }
          }
        }

        SpectrumMatch spectrumMatch = new SpectrumMatch(spectrumKey);
        if (!peptideAssumptions.isEmpty()) {

          PeptideAssumption bestPeptideAssumption = null;
          ArrayList<Double> ps = new ArrayList<Double>(peptideAssumptions.keySet());
          Collections.sort(ps);
          double retainedP = 0;

          for (double p : ps) {

            retainedP = p;
            HashMap<
                    Integer,
                    HashMap<
                        Integer,
                        HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>>
                pMap = peptideAssumptions.get(p);
            ArrayList<Integer> proteinMaxs = new ArrayList<Integer>(pMap.keySet());
            Collections.sort(proteinMaxs, Collections.reverseOrder());

            for (int proteinMax : proteinMaxs) {

              HashMap<
                      Integer,
                      HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>>>
                  proteinMaxMap = pMap.get(proteinMax);
              ArrayList<Integer> nSEs = new ArrayList<Integer>(proteinMaxMap.keySet());
              Collections.sort(nSEs, Collections.reverseOrder());

              for (int nSE : nSEs) {

                HashMap<Integer, HashMap<Double, HashMap<String, PeptideAssumption>>> nSeMap =
                    proteinMaxMap.get(nSE);
                ArrayList<Integer> coverages = new ArrayList<Integer>(nSeMap.keySet());
                Collections.sort(coverages, Collections.reverseOrder());

                for (Integer coverage : coverages) {

                  HashMap<Double, HashMap<String, PeptideAssumption>> coverageMap =
                      nSeMap.get(coverage);
                  ArrayList<Double> minErrors = new ArrayList<Double>(coverageMap.keySet());
                  Collections.sort(minErrors);

                  for (double minError : minErrors) {

                    HashMap<String, PeptideAssumption> bestPeptideAssumptions =
                        coverageMap.get(minError);
                    ArrayList<String> sequences =
                        new ArrayList<String>(bestPeptideAssumptions.keySet());
                    Collections.sort(sequences);

                    for (String sequence : sequences) {
                      PeptideAssumption peptideAssumption = bestPeptideAssumptions.get(sequence);
                      if (idFilter.validateProteins(
                          peptideAssumption.getPeptide(), sequenceMatchingPreferences)) {
                        bestPeptideAssumption = peptideAssumption;
                        break;
                      }
                    }
                    if (bestPeptideAssumption != null) {
                      break;
                    }
                  }
                  if (bestPeptideAssumption != null) {
                    break;
                  }
                }
                if (bestPeptideAssumption != null) {
                  break;
                }
              }
              if (bestPeptideAssumption != null) {
                break;
              }
            }
            if (bestPeptideAssumption != null) {
              break;
            }
          }
          if (bestPeptideAssumption != null) {

            if (multiSE) {

              // try to find the most likely modification localization based on the search engine
              // results
              HashMap<PeptideAssumption, ArrayList<Double>> assumptionPEPs =
                  new HashMap<PeptideAssumption, ArrayList<Double>>();
              String bestAssumptionKey =
                  bestPeptideAssumption.getPeptide().getMatchingKey(sequenceMatchingPreferences);

              for (int searchEngine : assumptions.keySet()) {

                boolean found = false;
                HashMap<Double, ArrayList<SpectrumIdentificationAssumption>> advocateMap =
                    assumptions.get(searchEngine);
                ArrayList<Double> eValues = new ArrayList<Double>(advocateMap.keySet());
                Collections.sort(eValues);

                for (double eValue : eValues) {
                  for (SpectrumIdentificationAssumption assumption : advocateMap.get(eValue)) {

                    if (assumption instanceof PeptideAssumption) {

                      PeptideAssumption peptideAssumption = (PeptideAssumption) assumption;

                      if (peptideAssumption
                          .getPeptide()
                          .getMatchingKey(sequenceMatchingPreferences)
                          .equals(bestAssumptionKey)) {

                        found = true;
                        boolean found2 = false;

                        for (PeptideAssumption assumption1 : assumptionPEPs.keySet()) {
                          if (assumption1
                              .getPeptide()
                              .sameModificationsAs(peptideAssumption.getPeptide())) {
                            found2 = true;
                            psParameter = (PSParameter) assumption.getUrParam(psParameter);
                            ArrayList<Double> peps = assumptionPEPs.get(assumption1);
                            peps.add(psParameter.getSearchEngineProbability());
                            break;
                          }
                        }

                        if (!found2) {
                          ArrayList<Double> peps = new ArrayList<Double>(1);
                          assumptionPEPs.put(peptideAssumption, peps);
                          psParameter = (PSParameter) assumption.getUrParam(psParameter);
                          peps.add(psParameter.getSearchEngineProbability());
                        }
                      }
                    }
                  }

                  if (found) {
                    break;
                  }
                }
              }

              Double bestSeP = null;
              int nSe = -1;

              for (PeptideAssumption peptideAssumption : assumptionPEPs.keySet()) {

                ArrayList<Double> peps = assumptionPEPs.get(peptideAssumption);
                Double sep = Collections.min(peps);

                if (bestSeP == null || bestSeP > sep) {
                  bestSeP = sep;
                  nSe = peps.size();
                  bestPeptideAssumption = peptideAssumption;
                } else if (peps.size() > nSe) {
                  if (sep != null && (Math.abs(sep - bestSeP) <= 1e-10)) {
                    nSe = peps.size();
                    bestPeptideAssumption = peptideAssumption;
                  }
                }
              }
            }

            // create a PeptideShaker match based on the best search engine match
            Peptide sePeptide = bestPeptideAssumption.getPeptide();
            ArrayList<String> psProteins =
                new ArrayList<String>(sePeptide.getParentProteins(sequenceMatchingPreferences));
            ArrayList<ModificationMatch> psModificationMatches = null;
            if (sePeptide.isModified()) {
              psModificationMatches =
                  new ArrayList<ModificationMatch>(sePeptide.getNModifications());
              for (ModificationMatch seModMatch : sePeptide.getModificationMatches()) {
                psModificationMatches.add(
                    new ModificationMatch(
                        seModMatch.getTheoreticPtm(),
                        seModMatch.isVariable(),
                        seModMatch.getModificationSite()));
              }
            }

            Peptide psPeptide = new Peptide(sePeptide.getSequence(), psModificationMatches);
            psPeptide.setParentProteins(psProteins);
            PeptideAssumption psAssumption =
                new PeptideAssumption(
                    psPeptide,
                    1,
                    Advocate.peptideShaker.getIndex(),
                    bestPeptideAssumption.getIdentificationCharge(),
                    retainedP);

            spectrumMatch.setBestPeptideAssumption(psAssumption);

            if (orderedPsmMap != null) {
              String peptideKey = psPeptide.getMatchingKey(sequenceMatchingPreferences);
              ArrayList<String> spectrumKeys = keysMap.get(peptideKey);
              if (spectrumKeys == null) {
                spectrumKeys = new ArrayList<String>();
                keysMap.put(peptideKey, spectrumKeys);
              }
              spectrumKeys.add(spectrumKey);
            }

            psParameter = new PSParameter();
            psParameter.setSpectrumProbabilityScore(retainedP);

            PSParameter matchParameter =
                (PSParameter) bestPeptideAssumption.getUrParam(psParameter);
            psParameter.setSearchEngineProbability(matchParameter.getSearchEngineProbability());
            psParameter.setAlgorithmDeltaPEP(matchParameter.getAlgorithmDeltaPEP());
            psParameter.setDeltaPEP(matchParameter.getDeltaPEP());

            matchesValidator
                .getPsmMap()
                .addPoint(
                    psParameter.getPsmProbabilityScore(),
                    spectrumMatch,
                    sequenceMatchingPreferences);
            psParameter.setSpecificMapKey(
                spectrumMatch.getBestPeptideAssumption().getIdentificationCharge().value + "");
            identification.addSpectrumMatchParameter(spectrumKey, psParameter);
            identification.updateSpectrumMatch(spectrumMatch);
          }
        }
        if (!tagAssumptions.isEmpty()) {
          ArrayList<Double> evalues = new ArrayList<Double>(tagAssumptions.keySet());
          Double bestEvalue = Collections.min(evalues);
          TagAssumption bestAssumption = tagAssumptions.get(bestEvalue).get(0);
          spectrumMatch.setBestTagAssumption(bestAssumption);
          identification.updateSpectrumMatch(spectrumMatch);
          if (spectrumMatch.getBestPeptideAssumption() == null) {
            psParameter = new PSParameter();
            if (!multiSE) {
              psParameter.setSpectrumProbabilityScore(bestEvalue);
            }
            PSParameter matchParameter = (PSParameter) bestAssumption.getUrParam(psParameter);
            psParameter.setSearchEngineProbability(matchParameter.getSearchEngineProbability());
            psParameter.setAlgorithmDeltaPEP(matchParameter.getAlgorithmDeltaPEP());
            psParameter.setDeltaPEP(matchParameter.getDeltaPEP());
            psParameter.setSpecificMapKey(
                spectrumMatch.getBestTagAssumption().getIdentificationCharge().value + "");
            identification.addSpectrumMatchParameter(spectrumKey, psParameter);
          }
        }
        waitingHandler.increaseSecondaryProgressCounter();
        if (waitingHandler.isRunCanceled()) {
          return;
        }
      }

      if (orderedPsmMap != null) {
        ArrayList<String> orderedKeys =
            new ArrayList<String>(
                identification.getSpectrumIdentification(spectrumFileName).size());
        for (ArrayList<String> keys : keysMap.values()) {
          orderedKeys.addAll(keys);
        }
        orderedPsmMap.put(spectrumFileName, orderedKeys);

        if (MemoryConsumptionStatus.memoryUsed() > 0.9) {
          orderedPsmMap = null;
        }
      }
    }

    if (orderedPsmMap != null) {
      metrics.setOrderedSpectrumKeys(orderedPsmMap);
    }

    // the protein count map is no longer needed
    proteinCount.clear();

    waitingHandler.setSecondaryProgressCounterIndeterminate(true);
  }

  /**
   * Selects a first hit in a list of equally scoring peptide matches. The selection is made based
   * on: 1 - The occurrence of the protein detection as given in the proteinCount map 2 - The
   * sequence coverage by fragment ions 3 - The precursor mass error.
   *
   * <p>If no best hit is found, the first one sorted alphabetically is retained.
   *
   * @param spectrumKey the key of the spectrum
   * @param firstHits list of equally scoring peptide matches
   * @param proteinCount map of the number of peptides for every protein
   * @param sequenceMatchingPreferences the sequence matching preferences
   * @param shotgunProtocol the shotgun protocol
   * @param identificationParameters the identification parameters
   * @param spectrumAnnotator the spectrum annotator to use
   * @return a first hit from the list of equally scoring peptide matches
   * @throws IOException exception thrown whenever an IO exception occurred while remapping the
   *     proteins or getting the spectrum
   * @throws InterruptedException exception thrown whenever an interrupted exception occurred while
   *     remapping the proteins or getting the spectrum
   * @throws SQLException exception thrown whenever an SQL exception occurred while interacting with
   *     the protein tree
   * @throws ClassNotFoundException exception thrown whenever an exception occurred while
   *     deserializing an object
   * @throws MzMLUnmarshallerException exception thrown whenever an exception occurred while reading
   *     an mzML file
   */
  public static PeptideAssumption getBestHit(
      String spectrumKey,
      ArrayList<PeptideAssumption> firstHits,
      HashMap<String, Integer> proteinCount,
      SequenceMatchingPreferences sequenceMatchingPreferences,
      ShotgunProtocol shotgunProtocol,
      IdentificationParameters identificationParameters,
      PeptideSpectrumAnnotator spectrumAnnotator)
      throws IOException, InterruptedException, SQLException, ClassNotFoundException,
          MzMLUnmarshallerException {

    if (firstHits.size() == 1) {
      return firstHits.get(0);
    }

    Integer maxProteins = 0;
    ArrayList<PeptideAssumption> bestPeptideAssumptions =
        new ArrayList<PeptideAssumption>(firstHits.size());

    for (PeptideAssumption peptideAssumption : firstHits) {
      for (String accession :
          peptideAssumption.getPeptide().getParentProteins(sequenceMatchingPreferences)) {
        Integer count = proteinCount.get(accession);
        if (count != null) {
          if (count > maxProteins) {
            maxProteins = count;
            bestPeptideAssumptions.clear();
            bestPeptideAssumptions.add(peptideAssumption);
          } else if (count.equals(maxProteins)) {
            bestPeptideAssumptions.add(peptideAssumption);
          }
        }
      }
    }

    if (bestPeptideAssumptions.size() == 1) {
      return bestPeptideAssumptions.get(0);
    } else if (!bestPeptideAssumptions.isEmpty()) {
      firstHits = bestPeptideAssumptions;
      bestPeptideAssumptions = new ArrayList<PeptideAssumption>(firstHits.size());
    }

    MSnSpectrum spectrum = (MSnSpectrum) SpectrumFactory.getInstance().getSpectrum(spectrumKey);
    int maxCoveredAminoAcids = 0;
    AnnotationSettings annotationPreferences = identificationParameters.getAnnotationPreferences();

    for (PeptideAssumption peptideAssumption : firstHits) {
      Peptide peptide = peptideAssumption.getPeptide();
      SpecificAnnotationSettings specificAnnotationPreferences =
          annotationPreferences.getSpecificAnnotationPreferences(
              spectrum.getSpectrumKey(),
              peptideAssumption,
              identificationParameters.getSequenceMatchingPreferences(),
              identificationParameters.getPtmScoringPreferences().getSequenceMatchingPreferences());
      HashMap<Integer, ArrayList<IonMatch>> coveredAminoAcids =
          spectrumAnnotator.getCoveredAminoAcids(
              annotationPreferences,
              specificAnnotationPreferences,
              (MSnSpectrum) spectrum,
              peptide);
      int nAas = coveredAminoAcids.size();
      if (nAas > maxCoveredAminoAcids) {
        maxCoveredAminoAcids = nAas;
        bestPeptideAssumptions.clear();
        bestPeptideAssumptions.add(peptideAssumption);
      } else if (nAas == maxCoveredAminoAcids) {
        bestPeptideAssumptions.add(peptideAssumption);
      }
    }

    if (bestPeptideAssumptions.size() == 1) {
      return bestPeptideAssumptions.get(0);
    } else if (!bestPeptideAssumptions.isEmpty()) {
      firstHits = bestPeptideAssumptions;
      bestPeptideAssumptions = new ArrayList<PeptideAssumption>(firstHits.size());
    }

    double minMassError = identificationParameters.getPeptideAssumptionFilter().getMaxMzDeviation();
    if (minMassError == -1.0) {
      minMassError = identificationParameters.getSearchParameters().getPrecursorAccuracy();
    }

    for (PeptideAssumption peptideAssumption : firstHits) {
      double massError =
          Math.abs(
              peptideAssumption.getDeltaMass(
                  spectrum.getPrecursor().getMz(), shotgunProtocol.isMs1ResolutionPpm()));
      if (massError < minMassError) {
        minMassError = massError;
        bestPeptideAssumptions.clear();
        bestPeptideAssumptions.add(peptideAssumption);
      } else if (massError == minMassError) {
        bestPeptideAssumptions.add(peptideAssumption);
      }
    }

    if (bestPeptideAssumptions.size() == 1) {
      return bestPeptideAssumptions.get(0);
    } else if (bestPeptideAssumptions.isEmpty()) {
      bestPeptideAssumptions = firstHits;
    }

    HashMap<String, PeptideAssumption> sequenceToPeptideAssumptionsMap =
        new HashMap<String, PeptideAssumption>(bestPeptideAssumptions.size());
    for (PeptideAssumption peptideAssumption : bestPeptideAssumptions) {
      sequenceToPeptideAssumptionsMap.put(
          peptideAssumption.getPeptide().getSequence(), peptideAssumption);
    }

    ArrayList<String> sequences = new ArrayList<String>(sequenceToPeptideAssumptionsMap.keySet());
    Collections.sort(sequences);
    return sequenceToPeptideAssumptionsMap.get(sequences.get(0));
  }
}
コード例 #7
0
public class PSFileImporter {

  private File currentPSFile;
  private EnzymeFactory enzymeFactory = EnzymeFactory.getInstance();
  private String resource;
  /** The spectrum annotator. */
  private SpectrumAnnotator spectrumAnnotator = new SpectrumAnnotator();
  /** The project details. */
  private ProjectDetails projectDetails = null;
  /** The spectrum factory. */
  private SpectrumFactory spectrumFactory = SpectrumFactory.getInstance(100);
  /** The identification to display. */
  private Identification identification;
  /** The compomics PTM factory. */
  private PTMFactory ptmFactory = PTMFactory.getInstance();
  /** The parameters of the search. */
  private SearchParameters searchParameters = new SearchParameters();
  /** The initial processing preferences */
  private ProcessingPreferences processingPreferences = new ProcessingPreferences();
  /** The annotation preferences. */
  private AnnotationPreferences annotationPreferences = new AnnotationPreferences();
  /** The spectrum counting preferences. */
  private SpectrumCountingPreferences spectrumCountingPreferences =
      new SpectrumCountingPreferences();
  /** The PTM scoring preferences */
  private PTMScoringPreferences ptmScoringPreferences = new PTMScoringPreferences();
  /** The identification filter used for this project. */
  private IdFilter idFilter = new IdFilter();

  /** The actually identified modifications. */
  /**
   * Returns the modifications found in this project.
   *
   * @return the modifications found in this project
   */
  public ArrayList<String> getFoundModifications() {
    if (identifiedModifications == null) {
      identifiedModifications = new ArrayList<String>();
      for (String peptideKey : identification.getPeptideIdentification()) {

        boolean modified = false;

        for (String modificationName : Peptide.getModificationFamily(peptideKey)) {
          if (!identifiedModifications.contains(modificationName)) {
            identifiedModifications.add(modificationName);
            modified = true;
          }
        }
        if (!modified && !identifiedModifications.contains(PtmPanel.NO_MODIFICATION)) {
          identifiedModifications.add(PtmPanel.NO_MODIFICATION);
        }
      }
    }
    return identifiedModifications;
  }

  private ArrayList<String> identifiedModifications = null;
  /** Metrics picked-up while loading the files. */
  private Metrics metrics;
  /** The display preferences. */
  private DisplayPreferences displayPreferences = new DisplayPreferences();
  /** The sequence factory. */
  private SequenceFactory sequenceFactory = SequenceFactory.getInstance(30000);
  /** The filter preferences. */
  private FilterPreferences filterPreferences = new FilterPreferences();
  /** The compomics experiment. */
  private MsExperiment experiment = null;
  /** The investigated sample. */
  private Sample sample;
  /** The replicate number. */
  private int replicateNumber;
  /** The class used to provide sexy features out of the identification. */
  private IdentificationFeaturesGenerator identificationFeaturesGenerator;
  /** The last folder opened by the user. Defaults to user.home. */
  private String lastSelectedFolder = "user.home";
  /** The object cache used for the identification database. */
  private ObjectsCache objectsCache;

  private com.compomics.util.experiment.ProteomicAnalysis proteomicAnalysis;
  private ProgressDialogX progressDialog;
  private javax.swing.JProgressBar jprog;

  public PSFileImporter(javax.swing.JProgressBar jprog) {
    this.progressDialog = new ProgressDialogX(false);
    this.jprog = jprog;
  }

  public void importPeptideShakerFile(File aPsFile, final String resource) {

    this.resource = resource;
    this.currentPSFile = aPsFile;
    loadGeneMapping();
    loadEnzymes();
    resetPtmFactory();
    // setDefaultPreferences(); // @TODO: i tried re-adding this but then we get a null pointer, but
    // the two below have to be added or the default neutral losses won't appear
    IonFactory.getInstance().addDefaultNeutralLoss(NeutralLoss.H2O);
    IonFactory.getInstance().addDefaultNeutralLoss(NeutralLoss.NH3);

    // exceptionHandler = new ExceptionHandler(this);

    new Thread("ProgressThread") {
      @Override
      public void run() {
        jprog.setValue(10);
      }
    }.start();

    Thread importThread =
        new Thread("ImportThread") {
          @Override
          public void run() {
            try {
              // reset enzymes, ptms and preferences
              loadEnzymes();
              resetPtmFactory();
              setDefaultPreferences();
              try {
                // close any open connection to an identification database
                if (identification != null) {
                  identification.close();
                }
              } catch (Exception e) {
                e.printStackTrace();
              }
              File experimentFile =
                  new File(
                      PeptideShaker.SERIALIZATION_DIRECTORY, PeptideShaker.experimentObjectName);
              File matchFolder = new File(PeptideShaker.SERIALIZATION_DIRECTORY);
              // empty the existing files in the matches folder
              if (matchFolder.exists()) {
                for (File file : matchFolder.listFiles()) {
                  if (file.isDirectory()) {
                    boolean deleted = Util.deleteDir(file);

                    if (!deleted) {
                      System.out.println("Failed to delete folder: " + file.getPath());
                    }
                  } else {
                    boolean deleted = file.delete();

                    if (!deleted) {
                      System.out.println("Failed to delete file: " + file.getPath());
                    }
                  }
                }
              }
              final int BUFFER = 2048;
              byte data[] = new byte[BUFFER];
              FileInputStream fi = new FileInputStream(currentPSFile);
              BufferedInputStream bis = new BufferedInputStream(fi, BUFFER);
              try {
                ArchiveInputStream tarInput =
                    new ArchiveStreamFactory().createArchiveInputStream(bis);
                ArchiveEntry archiveEntry;

                while ((archiveEntry = tarInput.getNextEntry()) != null) {
                  File destinationFile = new File(archiveEntry.getName());
                  File destinationFolder = destinationFile.getParentFile();
                  boolean destFolderExists = true;
                  if (!destinationFolder.exists()) {
                    destFolderExists = destinationFolder.mkdirs();
                  }
                  if (destFolderExists) {
                    FileOutputStream fos = new FileOutputStream(destinationFile);
                    BufferedOutputStream bos = new BufferedOutputStream(fos);
                    int count;
                    while ((count = tarInput.read(data, 0, BUFFER)) != -1
                        && !progressDialog.isRunCanceled()) {
                      bos.write(data, 0, count);
                    }

                    bos.close();
                    fos.close();

                    //	                                int progress = (int) (100 *
                    // tarInput.getBytesRead() / fileLength);
                    //	                               progressDialog.setValue(progress);
                  } else {
                    System.out.println(
                        "Folder does not exist: \'"
                            + destinationFolder.getAbsolutePath()
                            + "\'. User preferences not saved.");
                  }
                }
                tarInput.close();
              } catch (ArchiveException e) {
                // Most likely an old project
                experimentFile = currentPSFile;
                e.printStackTrace();
              }
              fi.close();
              bis.close();
              fi.close();

              MsExperiment tempExperiment = ExperimentIO.loadExperiment(experimentFile);
              Sample tempSample = null;
              PeptideShakerSettings experimentSettings = new PeptideShakerSettings();
              if (tempExperiment.getUrParam(experimentSettings) instanceof PSSettings) {
                // convert old settings files using utilities version 3.10.68 or older
                // convert the old ProcessingPreferences object
                PSSettings tempSettings =
                    (PSSettings) tempExperiment.getUrParam(experimentSettings);
                ProcessingPreferences tempProcessingPreferences = new ProcessingPreferences();
                tempProcessingPreferences.setProteinFDR(
                    tempSettings.getProcessingPreferences().getProteinFDR());
                tempProcessingPreferences.setPeptideFDR(
                    tempSettings.getProcessingPreferences().getPeptideFDR());
                tempProcessingPreferences.setPsmFDR(
                    tempSettings.getProcessingPreferences().getPsmFDR());
                // convert the old PTMScoringPreferences object
                PTMScoringPreferences tempPTMScoringPreferences = new PTMScoringPreferences();
                tempPTMScoringPreferences.setaScoreCalculation(
                    tempSettings.getPTMScoringPreferences().aScoreCalculation());
                tempPTMScoringPreferences.setaScoreNeutralLosses(
                    tempSettings.getPTMScoringPreferences().isaScoreNeutralLosses());
                tempPTMScoringPreferences.setFlrThreshold(
                    tempSettings.getPTMScoringPreferences().getFlrThreshold());
                // missing gene refrences
                GenePreferences genePreferences = getGenePreferences();
                //     String selectedSpecies = genePreferences.getCurrentSpecies();
                //    String speciesDatabase =
                // genePreferences.getEnsemblDatabaseName(selectedSpecies);

                experimentSettings =
                    new PeptideShakerSettings(
                        tempSettings.getSearchParameters(),
                        tempSettings.getAnnotationPreferences(),
                        tempSettings.getSpectrumCountingPreferences(),
                        tempSettings.getProjectDetails(),
                        tempSettings.getFilterPreferences(),
                        tempSettings.getDisplayPreferences(),
                        tempSettings.getMetrics(),
                        tempProcessingPreferences,
                        tempSettings.getIdentificationFeaturesCache(),
                        tempPTMScoringPreferences,
                        genePreferences,
                        new IdFilter());
                ;
              } else {
                experimentSettings =
                    (PeptideShakerSettings) tempExperiment.getUrParam(experimentSettings);
              }

              idFilter = experimentSettings.getIdFilter();
              setAnnotationPreferences(experimentSettings.getAnnotationPreferences());
              setSpectrumCountingPreferences(experimentSettings.getSpectrumCountingPreferences());
              setPtmScoringPreferences(experimentSettings.getPTMScoringPreferences());
              setProjectDetails(experimentSettings.getProjectDetails());
              setSearchParameters(experimentSettings.getSearchParameters());
              setProcessingPreferences(experimentSettings.getProcessingPreferences());
              setMetrics(experimentSettings.getMetrics());
              setDisplayPreferences(experimentSettings.getDisplayPreferences());

              if (experimentSettings.getFilterPreferences() != null) {
                setFilterPreferences(experimentSettings.getFilterPreferences());
              } else {
                setFilterPreferences(new FilterPreferences());
              }
              if (experimentSettings.getDisplayPreferences() != null) {
                setDisplayPreferences(experimentSettings.getDisplayPreferences());
                displayPreferences.compatibilityCheck(searchParameters.getModificationProfile());
              } else {
                setDisplayPreferences(new DisplayPreferences());
                displayPreferences.setDefaultSelection(searchParameters.getModificationProfile());
              }
              ArrayList<Sample> samples = new ArrayList(tempExperiment.getSamples().values());

              if (samples.size() == 1) {
                tempSample = samples.get(0);
              } else {
                tempSample = samples.get(0);
                String[] sampleNames = new String[samples.size()];
                for (int cpt = 0; cpt < sampleNames.length; cpt++) {
                  sampleNames[cpt] = samples.get(cpt).getReference();
                  System.out.println(sampleNames[cpt]);
                }
                SampleSelection sampleSelection =
                    new SampleSelection(null, true, sampleNames, "sample");
                sampleSelection.setVisible(false);
                String choice = sampleSelection.getChoice();
                for (Sample sampleTemp : samples) {
                  if (sampleTemp.getReference().equals(choice)) {
                    tempSample = sampleTemp;
                    break;
                  }
                }
              }

              ArrayList<Integer> replicates =
                  new ArrayList(tempExperiment.getAnalysisSet(tempSample).getReplicateNumberList());

              System.out.println(replicates);
              int tempReplicate;

              if (replicates.size() == 1) {
                tempReplicate = replicates.get(0);
              } else {
                String[] replicateNames = new String[replicates.size()];
                for (int cpt = 0; cpt < replicateNames.length; cpt++) {
                  replicateNames[cpt] = samples.get(cpt).getReference();
                }
                SampleSelection sampleSelection =
                    new SampleSelection(null, true, replicateNames, "replicate");
                sampleSelection.setVisible(false);
                Integer choice = new Integer(sampleSelection.getChoice());
                tempReplicate = 0;
              }

              setProject(tempExperiment, tempSample, tempReplicate);

              identificationFeaturesGenerator =
                  new IdentificationFeaturesGenerator(
                      identification,
                      searchParameters,
                      idFilter,
                      metrics,
                      spectrumCountingPreferences);
              if (experimentSettings.getIdentificationFeaturesCache() != null) {
                identificationFeaturesGenerator.setIdentificationFeaturesCache(
                    experimentSettings.getIdentificationFeaturesCache());
              }

              //	                    mainProgressDialog.setTitle("Loading FASTA File. Please
              // Wait...");

              try {
                File providedFastaLocation =
                    experimentSettings.getSearchParameters().getFastaFile();
                String fileName = providedFastaLocation.getName();
                File projectFolder = currentPSFile.getParentFile();
                File dataFolder = new File(projectFolder, "data");

                // try to locate the FASTA file
                if (providedFastaLocation.exists()) {
                  SequenceFactory.getInstance().loadFastaFile(providedFastaLocation);
                } else if (new File(projectFolder, fileName).exists()) {
                  SequenceFactory.getInstance().loadFastaFile(new File(projectFolder, fileName));
                  experimentSettings
                      .getSearchParameters()
                      .setFastaFile(new File(projectFolder, fileName));
                } else if (new File(dataFolder, fileName).exists()) {
                  SequenceFactory.getInstance().loadFastaFile(new File(dataFolder, fileName));
                  experimentSettings
                      .getSearchParameters()
                      .setFastaFile(new File(dataFolder, fileName));
                } else {
                  // return error

                  System.out.println("fastafile is missing");
                }
              } catch (Exception e) {
                e.printStackTrace();
                System.out.println("fastafile is missing");
              }

              //	                 mainProgressDialog.setTitle("Locating Spectrum Files. Please
              // Wait...");

              for (String spectrumFileName : identification.getSpectrumFiles()) {

                try {
                  File providedSpectrumLocation = projectDetails.getSpectrumFile(spectrumFileName);
                  // try to locate the spectrum file
                  if (providedSpectrumLocation == null || !providedSpectrumLocation.exists()) {
                    File projectFolder = currentPSFile.getParentFile();
                    File fileInProjectFolder = new File(projectFolder, spectrumFileName);
                    File dataFolder = new File(projectFolder, "data");
                    File fileInDataFolder = new File(dataFolder, spectrumFileName);
                    File fileInLastSelectedFolder =
                        new File(getLastSelectedFolder(), spectrumFileName);
                    if (fileInProjectFolder.exists()) {
                      projectDetails.addSpectrumFile(fileInProjectFolder);
                    } else if (fileInDataFolder.exists()) {
                      projectDetails.addSpectrumFile(fileInDataFolder);
                    } else if (fileInLastSelectedFolder.exists()) {
                      projectDetails.addSpectrumFile(fileInLastSelectedFolder);
                    } else {

                      System.out.println("error no file");
                    }
                  }
                } catch (Exception e) {
                  clearData(true);
                  // clearPreferences();
                  e.printStackTrace();
                  System.out.println("error no file");
                  return;
                }
              }

              objectsCache = new ObjectsCache();
              objectsCache.setAutomatedMemoryManagement(true);

              if (identification.isDB()) {
                try {
                  String dbFolder =
                      new File(resource, PeptideShaker.SERIALIZATION_DIRECTORY).getAbsolutePath();
                  identification.establishConnection(dbFolder, false, objectsCache);
                } catch (Exception e) {
                  e.printStackTrace();
                }
              } else {
                updateAnnotationPreferencesFromSearchSettings();
                annotationPreferences.useAutomaticAnnotation(true);
              }

              int cpt = 1, nfiles = identification.getSpectrumFiles().size();
              for (String fileName : identification.getSpectrumFiles()) {

                //                             mainProgressDialog.setTitle("Importing Spectrum
                // Files. Please Wait...");
                try {
                  File mgfFile = projectDetails.getSpectrumFile(fileName);
                  spectrumFactory.addSpectra(mgfFile, progressDialog);
                } catch (Exception e) {
                  clearData(true);
                  e.printStackTrace();
                  return;
                }
              }
              boolean compatibilityIssue =
                  getSearchParameters().getIonSearched1() == null
                      || getSearchParameters().getIonSearched2() == null;

              if (compatibilityIssue) {
                JOptionPane.showMessageDialog(
                    null,
                    "The annotation preferences for this project may have changed.\n\n"
                        + "Note that PeptideShaker has substancially improved, we strongly\n"
                        + "recommend reprocessing your identification files.",
                    "Annotation Preferences",
                    JOptionPane.INFORMATION_MESSAGE);
                updateAnnotationPreferencesFromSearchSettings();
              }

              if (identification.getSpectrumIdentificationMap() == null) {
                // 0.18 version, needs update of the spectrum mapping
                identification.updateSpectrumMapping();
              }
            } catch (OutOfMemoryError error) {
              System.out.println(
                  "Ran out of memory! (runtime.maxMemory(): "
                      + Runtime.getRuntime().maxMemory()
                      + ")");
              Runtime.getRuntime().gc();
              JOptionPane.showMessageDialog(
                  null,
                  "The task used up all the available memory and had to be stopped.\n"
                      + "Memory boundaries are set in ../resources/conf/JavaOptions.txt.",
                  "Out Of Memory Error",
                  JOptionPane.ERROR_MESSAGE);
              error.printStackTrace();
            } catch (Exception exp) {
              exp.printStackTrace();
            }
          }
        };
    importThread.setPriority(Thread.MAX_PRIORITY);
    //        importThread.start();
    //        while (importThread.isAlive()) {
    //            try {
    //                Thread.currentThread().sleep(100);
    //
    //            } catch (Exception e) {
    //                e.printStackTrace();
    //            }
    //        }
    ExecutorService es = Executors.newCachedThreadPool();
    es.execute(importThread);
    es.shutdown();
    try {
      boolean finshed = es.awaitTermination(1, TimeUnit.DAYS);
      System.gc();
      return;

      //        t.start();
    } catch (InterruptedException ex) {
      System.err.println(ex.getMessage());
      // Logger.getLogger(UpdatedOutputGenerator.class.getName()).log(Level.SEVERE, null, ex);
    }
    System.gc();
    //        return;

  }

  /** Loads the enzymes from the enzyme file into the enzyme factory. */
  private void loadEnzymes() {
    try {
      enzymeFactory.importEnzymes(new File(resource, PeptideShaker.ENZYME_FILE));
    } catch (Exception e) {
      System.out.println("Not able to load the enzyme file." + "Wrong enzyme file.");
      e.printStackTrace();
    }
  }

  /** Loads the modifications from the modification file. */
  public void resetPtmFactory() {
    // reset ptm factory
    ptmFactory.reloadFactory();
    ptmFactory = PTMFactory.getInstance();
    try {
      ptmFactory.importModifications(new File(resource, PeptideShaker.MODIFICATIONS_FILE), false);
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      ptmFactory.importModifications(
          new File(resource, PeptideShaker.USER_MODIFICATIONS_FILE), true);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

  /** Set the default preferences. */
  private void setDefaultPreferences() {
    searchParameters = new SearchParameters();
    annotationPreferences.setAnnotationLevel(0.75);
    annotationPreferences.useAutomaticAnnotation(true);
    spectrumCountingPreferences.setSelectedMethod(SpectralCountingMethod.NSAF);
    spectrumCountingPreferences.setValidatedHits(true);
    IonFactory.getInstance().addDefaultNeutralLoss(NeutralLoss.NH3);
    IonFactory.getInstance().addDefaultNeutralLoss(NeutralLoss.H2O);
    processingPreferences = new ProcessingPreferences();
    ptmScoringPreferences = new PTMScoringPreferences();
  }

  /** Imports the gene mapping. */
  private void loadGeneMapping() {
    try {
      geneFactory.initialize(new File(resource, GENE_MAPPING_PATH), null);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
  /** The path to the gene mapping file. */
  private final String GENE_MAPPING_PATH = "/resources/conf/gene_ontology/gene_details_human";
  /** The gene factory. */
  private GeneFactory geneFactory = GeneFactory.getInstance();

  /**
   * Updates the new annotation preferences.
   *
   * @param annotationPreferences the new annotation preferences
   */
  public void setAnnotationPreferences(AnnotationPreferences annotationPreferences) {
    this.annotationPreferences = annotationPreferences;
  }

  /**
   * Sets new spectrum counting preferences.
   *
   * @param spectrumCountingPreferences new spectrum counting preferences
   */
  public void setSpectrumCountingPreferences(
      SpectrumCountingPreferences spectrumCountingPreferences) {
    this.spectrumCountingPreferences = spectrumCountingPreferences;
  }

  /**
   * Sets the PTM scoring preferences
   *
   * @param ptmScoringPreferences the PTM scoring preferences
   */
  public void setPtmScoringPreferences(PTMScoringPreferences ptmScoringPreferences) {
    this.ptmScoringPreferences = ptmScoringPreferences;
  }

  /**
   * Sets the project details.
   *
   * @param projectDetails the project details
   */
  public void setProjectDetails(ProjectDetails projectDetails) {
    this.projectDetails = projectDetails;
  }

  /**
   * Updates the search parameters.
   *
   * @param searchParameters the new search parameters
   */
  public void setSearchParameters(SearchParameters searchParameters) {
    this.searchParameters = searchParameters;
    PeptideShaker.loadModifications(searchParameters);
  }

  /**
   * Sets the initial processing preferences.
   *
   * @param processingPreferences the initial processing preferences
   */
  public void setProcessingPreferences(ProcessingPreferences processingPreferences) {
    this.processingPreferences = processingPreferences;
  }

  /**
   * Sets the metrics saved while loading the files.
   *
   * @param metrics the metrics saved while loading the files
   */
  public void setMetrics(Metrics metrics) {
    this.metrics = metrics;
  }

  /**
   * Sets the display preferences to use.
   *
   * @param displayPreferences the display preferences to use
   */
  public void setDisplayPreferences(DisplayPreferences displayPreferences) {
    this.displayPreferences = displayPreferences;
  }
  /**
   * Sets the gui filter preferences to use. .\
   *
   * @param filterPreferences the gui filter preferences to use
   */
  public void setFilterPreferences(FilterPreferences filterPreferences) {
    this.filterPreferences = filterPreferences;
  }
  /**
   * This method sets the information of the project when opened.
   *
   * @param experiment the experiment conducted
   * @param sample The sample analyzed
   * @param replicateNumber The replicate number
   */
  public void setProject(MsExperiment experiment, Sample sample, int replicateNumber) {
    this.experiment = experiment;
    this.sample = sample;
    this.replicateNumber = replicateNumber;
    ProteomicAnalysis proteomic_Analysis =
        experiment.getAnalysisSet(sample).getProteomicAnalysis(replicateNumber);
    identification = proteomic_Analysis.getIdentification(IdentificationMethod.MS2_IDENTIFICATION);
  }

  /**
   * Returns the last selected folder.
   *
   * @return the last selected folder
   */
  public String getLastSelectedFolder() {
    return lastSelectedFolder;
  }

  /**
   * Set the last selected folder.
   *
   * @param lastSelectedFolder the folder to set
   */
  public void setLastSelectedFolder(String lastSelectedFolder) {
    this.lastSelectedFolder = lastSelectedFolder;
  }

  /**
   * Returns the identification displayed.
   *
   * @return the identification displayed
   */
  public com.compomics.util.experiment.identification.Identification getIdentification() {
    return identification;
  }

  /**
   * Returns the identification features generator.
   *
   * @return the identification features generator
   */
  public IdentificationFeaturesGenerator getIdentificationFeaturesGenerator() {
    return identificationFeaturesGenerator;
  }

  /**
   * Returns the search parameters.
   *
   * @return the search parameters
   */
  public SearchParameters getSearchParameters() {
    return searchParameters;
  }

  /**
   * Return the display preferences to use.
   *
   * @return the display preferences to use
   */
  public DisplayPreferences getDisplayPreferences() {
    return displayPreferences;
  }

  public ArrayList<IonMatch> getIonsCurrentlyMatched() throws MzMLUnmarshallerException {
    return spectrumAnnotator.getCurrentAnnotation(
        annotationPreferences.getIonTypes(),
        annotationPreferences.getNeutralLosses(),
        annotationPreferences.getValidatedCharges());
  }

  public SpectrumAnnotator getSpectrumAnnorator() {
    return spectrumAnnotator;
  }

  public void clearData(boolean clearDatabaseFolder) {
    projectDetails = null;
    spectrumAnnotator = new SpectrumAnnotator();
    try {
      spectrumFactory.closeFiles();
    } catch (Exception e) {
      e.printStackTrace();
    }
    try {
      sequenceFactory.closeFile();
    } catch (Exception e) {
      e.printStackTrace();
    }
    try {
      GOFactory.getInstance().closeFiles();
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      spectrumFactory.clearFactory();
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      sequenceFactory.clearFactory();
    } catch (Exception e) {
      e.printStackTrace();
    }

    try {
      GOFactory.getInstance().clearFactory();
    } catch (Exception e) {
      e.printStackTrace();
    }

    identifiedModifications = null;

    if (clearDatabaseFolder) {
      clearDatabaseFolder();
    }

    resetFeatureGenerator();

    // set up the tabs/panels

    currentPSFile = null;
  }

  /** Resets the feature generator. */
  public void resetFeatureGenerator() {
    identificationFeaturesGenerator =
        new IdentificationFeaturesGenerator(
            identification, searchParameters, idFilter, metrics, spectrumCountingPreferences);
  }

  /** Clears the database folder. */
  private void clearDatabaseFolder() {

    boolean databaseClosed = true;

    // close the database connection
    if (identification != null) {

      try {
        identification.close();
        identification = null;
      } catch (SQLException e) {
        databaseClosed = false;
        e.printStackTrace();
        JOptionPane.showMessageDialog(
            null, "Failed to close the database.", "Database Error", JOptionPane.WARNING_MESSAGE);
      }
    }

    // empty the matches folder
    if (databaseClosed) {
      File matchFolder = new File(resource, PeptideShaker.SERIALIZATION_DIRECTORY);

      if (matchFolder.exists()) {

        File[] tempFiles = matchFolder.listFiles();

        if (tempFiles != null) {
          for (File currentFile : tempFiles) {
            Util.deleteDir(currentFile);
          }
        }

        if (matchFolder.listFiles() != null && matchFolder.listFiles().length > 0) {
          JOptionPane.showMessageDialog(
              null,
              "Failed to empty the database folder:\n" + matchFolder.getPath() + ".",
              "Database Cleanup Failed",
              JOptionPane.WARNING_MESSAGE);
        }
      }
    }
  }

  /** Updates the ions used for fragment annotation. */
  public void updateAnnotationPreferencesFromSearchSettings() {
    annotationPreferences.setPreferencesFromSearchParamaers(searchParameters);
  }

  /**
   * Returns the gene preferences.
   *
   * @return the gene preferences
   */
  public GenePreferences getGenePreferences() {
    return genePreferences;
  }

  private GenePreferences genePreferences = new GenePreferences();

  /**
   * Returns the experiment.
   *
   * @return the experiment
   */
  public MsExperiment getExperiment() {
    return experiment;
  }

  /*
   * Returns the sample.
   * @return the sample
   */
  public Sample getSample() {
    return sample;
  }
  /**
   * Returns the replicate number.
   *
   * @return the replicateNumber
   */
  public int getReplicateNumber() {
    return this.replicateNumber;
  }

  /**
   * Returns the desired spectrum.
   *
   * @param spectrumKey the key of the spectrum
   * @return the desired spectrum
   */
  public MSnSpectrum getSpectrum(String spectrumKey) {
    String spectrumFile = Spectrum.getSpectrumFile(spectrumKey);
    String spectrumTitle = Spectrum.getSpectrumTitle(spectrumKey);
    try {
      return (MSnSpectrum) spectrumFactory.getSpectrum(spectrumFile, spectrumTitle);
    } catch (Exception e) {
      System.out.println(e.getMessage());
      return null;
    }
  }
}
コード例 #8
0
  /**
   * Indicates whether the match designated by the match key validates the given item using the
   * given comparator and value threshold.
   *
   * @param itemName the name of the item to filter on
   * @param filterItemComparator the comparator to use
   * @param value the value to use as a threshold
   * @param spectrumKey the key of the match of interest
   * @param peptideAssumption the assumption to validate
   * @param identification the identification objects where to get identification matches from
   * @param identificationFeaturesGenerator the identification feature generator where to get
   *     identification features
   * @param identificationParameters the identification parameters used
   * @param peptideSpectrumAnnotator the annotator to use to annotate spectra when filtering on PSM
   *     or assumptions
   * @return a boolean indicating whether the match designated by the protein key validates the
   *     given item using the given comparator and value threshold.
   * @throws java.io.IOException exception thrown whenever an exception occurred while reading or
   *     writing a file
   * @throws java.lang.InterruptedException exception thrown whenever a threading issue occurred
   *     while validating that the match passes the filter
   * @throws java.lang.ClassNotFoundException exception thrown whenever an error occurred while
   *     deserilalizing a match
   * @throws java.sql.SQLException exception thrown whenever an error occurred while interacting
   *     with a database
   * @throws uk.ac.ebi.jmzml.xml.io.MzMLUnmarshallerException exception thrown whenever an error
   *     occurred while reading an mzML file
   * @throws org.apache.commons.math.MathException exception thrown whenever an error occurred while
   *     doing statistics on a distribution
   */
  public boolean isValidated(
      String itemName,
      FilterItemComparator filterItemComparator,
      Object value,
      String spectrumKey,
      PeptideAssumption peptideAssumption,
      Identification identification,
      IdentificationFeaturesGenerator identificationFeaturesGenerator,
      IdentificationParameters identificationParameters,
      PeptideSpectrumAnnotator peptideSpectrumAnnotator)
      throws IOException, InterruptedException, ClassNotFoundException, SQLException,
          MzMLUnmarshallerException, MathException {

    AssumptionFilterItem filterItem = AssumptionFilterItem.getItem(itemName);
    if (filterItem == null) {
      throw new IllegalArgumentException(
          "Filter item " + itemName + "not recognized as spectrum assumption filter item.");
    }
    String input = value.toString();
    switch (filterItem) {
      case precrusorMz:
        Precursor precursor = SpectrumFactory.getInstance().getPrecursor(spectrumKey);
        Double mz = precursor.getMz();
        return filterItemComparator.passes(input, mz.toString());
      case precrusorRT:
        precursor = SpectrumFactory.getInstance().getPrecursor(spectrumKey);
        Double rt = precursor.getRt();
        return filterItemComparator.passes(input, rt.toString());
      case precrusorCharge:
        Integer charge = peptideAssumption.getIdentificationCharge().value;
        return filterItemComparator.passes(input, charge.toString());
      case precrusorMzErrorDa:
        precursor = SpectrumFactory.getInstance().getPrecursor(spectrumKey);
        SearchParameters searchParameters = identificationParameters.getSearchParameters();
        Double mzError =
            Math.abs(
                peptideAssumption.getDeltaMass(
                    precursor.getMz(),
                    false,
                    searchParameters.getMinIsotopicCorrection(),
                    searchParameters.getMaxIsotopicCorrection()));
        return filterItemComparator.passes(input, mzError.toString());
      case precrusorMzErrorPpm:
        searchParameters = identificationParameters.getSearchParameters();
        precursor = SpectrumFactory.getInstance().getPrecursor(spectrumKey);
        mzError =
            Math.abs(
                peptideAssumption.getDeltaMass(
                    precursor.getMz(),
                    true,
                    searchParameters.getMinIsotopicCorrection(),
                    searchParameters.getMaxIsotopicCorrection()));
        return filterItemComparator.passes(input, mzError.toString());
      case precrusorMzErrorStat:
        searchParameters = identificationParameters.getSearchParameters();
        precursor = SpectrumFactory.getInstance().getPrecursor(spectrumKey);
        mzError =
            peptideAssumption.getDeltaMass(
                precursor.getMz(),
                identificationParameters.getSearchParameters().isPrecursorAccuracyTypePpm(),
                searchParameters.getMinIsotopicCorrection(),
                searchParameters.getMaxIsotopicCorrection());
        NonSymmetricalNormalDistribution precDeviationDistribution =
            identificationFeaturesGenerator.getMassErrorDistribution(
                Spectrum.getSpectrumFile(spectrumKey));
        Double p;
        if (mzError > precDeviationDistribution.getMean()) {
          p = precDeviationDistribution.getDescendingCumulativeProbabilityAt(mzError);
        } else {
          p = precDeviationDistribution.getCumulativeProbabilityAt(mzError);
        }
        return filterItemComparator.passes(input, p.toString());
      case sequenceCoverage:
        SpectrumFactory spectrumFactory = SpectrumFactory.getInstance();
        MSnSpectrum spectrum = (MSnSpectrum) spectrumFactory.getSpectrum(spectrumKey);
        Peptide peptide = peptideAssumption.getPeptide();
        AnnotationSettings annotationPreferences =
            identificationParameters.getAnnotationPreferences();
        SpecificAnnotationSettings specificAnnotationPreferences =
            annotationPreferences.getSpecificAnnotationPreferences(
                spectrum.getSpectrumKey(),
                peptideAssumption,
                identificationParameters.getSequenceMatchingPreferences(),
                identificationParameters
                    .getPtmScoringPreferences()
                    .getSequenceMatchingPreferences());
        HashMap<Integer, ArrayList<IonMatch>> matches =
            peptideSpectrumAnnotator.getCoveredAminoAcids(
                annotationPreferences,
                specificAnnotationPreferences,
                (MSnSpectrum) spectrum,
                peptide);
        double nCovered = 0;
        int nAA = peptide.getSequence().length();
        for (int i = 0; i <= nAA; i++) {
          ArrayList<IonMatch> matchesAtAa = matches.get(i);
          if (matchesAtAa != null && !matchesAtAa.isEmpty()) {
            nCovered++;
          }
        }
        Double coverage = 100.0 * nCovered / nAA;
        return filterItemComparator.passes(input, coverage.toString());
      case algorithmScore:
        Double score = peptideAssumption.getRawScore();
        if (score == null) {
          score = peptideAssumption.getScore();
        }
        return filterItemComparator.passes(input, score.toString());
      case fileNames:
        return filterItemComparator.passes(input, Spectrum.getSpectrumFile(spectrumKey));
      case confidence:
        PSParameter psParameter = new PSParameter();
        psParameter =
            (PSParameter) identification.getPeptideMatchParameter(spectrumKey, psParameter);
        Double confidence = psParameter.getProteinConfidence();
        return filterItemComparator.passes(input, confidence.toString());
      case validationStatus:
        psParameter = new PSParameter();
        psParameter =
            (PSParameter) identification.getPeptideMatchParameter(spectrumKey, psParameter);
        Integer validation = psParameter.getMatchValidationLevel().getIndex();
        return filterItemComparator.passes(input, validation.toString());
      case stared:
        psParameter = new PSParameter();
        psParameter =
            (PSParameter) identification.getPeptideMatchParameter(spectrumKey, psParameter);
        String starred;
        if (psParameter.isStarred()) {
          starred = FilterItemComparator.trueFalse[0];
        } else {
          starred = FilterItemComparator.trueFalse[1];
        }
        return filterItemComparator.passes(input, starred);
      default:
        throw new IllegalArgumentException(
            "Protein filter not implemented for item " + filterItem.name + ".");
    }
  }