Changeset 1528


Ignore:
Timestamp:
Jan 30, 2007, 12:29:55 PM (14 years ago)
Author:
fredrik
Message:

Major revision of standard protein report to accomodate large lists. Filtering on the protein score and or peptide and protein score. Filtering by score type as well.

Location:
trunk/src/org/proteios
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/proteios/batch/ProteinHitsReportQueryAction.java

    r1525 r1528  
    130130  }
    131131
    132   public void setDescending(String descending)
    133   {
    134     protein_hits_report_query.setDescending(new Boolean(descending));
    135   }
    136   public String getDescending()
    137   {
    138     return "" + protein_hits_report_query.getDescending();
    139   }
    140132
    141133/*  public void setHitsPerGelItem(String hitsPerGelItem)
  • trunk/src/org/proteios/batch/ProteiosBatcher.java

    r1525 r1528  
    335335          current_protein_hits_report_query.setCutOffAbove(attrs.getValue(attrs.getIndex("cutOffAbove")));
    336336          current_protein_hits_report_query.setDate(attrs.getValue(attrs.getIndex("date")));
    337           current_protein_hits_report_query.setDescending(attrs.getValue(attrs.getIndex("descending")));
    338337          //current_protein_hits_report_query.setHitsPerGelItem(attrs.getValue(attrs.getIndex("hitsPerGelItem")));
    339338        }
  • trunk/src/org/proteios/gui/query/ProteinHitsReportEditor.java

    r1525 r1528  
    5757  {
    5858    ProteinHitsReportQuery pQuery = (ProteinHitsReportQuery)query;
    59     if (descendingButton.isSelected())
    60     {
    61       pQuery.setDescending(new Boolean(true));
     59    if (peptidesButton.isSelected())
     60    {
     61      pQuery.setPeptideFilter(new Boolean(true));
    6262    }
    6363    else
    6464    {
    65       pQuery.setDescending(new Boolean(false));
     65      pQuery.setPeptideFilter(new Boolean(false));
    6666    }
    6767    if (cutOffCheckBox.isSelected())
    6868    {
    6969      pQuery.setCutOff((Double)cutOffSpinner.getValue());
    70       if (aboveButton.isSelected())
    71       {
    72         pQuery.setCutOffAbove(new Boolean(true));
    73       }
    74       else
    75       {
    76         pQuery.setCutOffAbove(new Boolean(false));
    77       }
     70      pQuery.setCutOffAbove(new Boolean(true));
    7871    }
    7972    if (dateCheckBox.isSelected())
    8073    {
    8174      pQuery.setDate(dateText.getText());     
     75    }
     76    if (scoreTypeCheckBox.isSelected())
     77    {
     78      pQuery.setScoreTypeFilter(scoreTypeText.getText());     
    8279    }
    8380    pQuery.setReverseText(reverseText.getText());
     
    111108          if (cutOffCheckBox.isSelected())
    112109          {
    113             aboveButton.setEnabled(true);
    114             belowButton.setEnabled(true);
    115110            cutOffSpinner.setEnabled(true);
    116111          }
    117112          else if (!cutOffCheckBox.isSelected())
    118113          {
    119             aboveButton.setEnabled(false);
    120             belowButton.setEnabled(false);
    121114            cutOffSpinner.setEnabled(false);
    122115          }
     
    132125          {
    133126            dateText.setEnabled(false);
     127          }
     128        }
     129        /** Behaviour for the scoreTypePanel. */
     130        if ("score filter".equals(event.getActionCommand()))
     131        {
     132          if (scoreTypeCheckBox.isSelected())
     133          {
     134            scoreTypeText.setEnabled(true);
     135          }
     136          else if (!scoreTypeCheckBox.isSelected())
     137          {
     138            scoreTypeText.setEnabled(false);
    134139          }
    135140        }
     
    160165    sortingPanel.setBackground(new java.awt.Color(255, 255, 255));
    161166   
    162     JLabel sortingLabel = new JLabel("Sort by e-values:  ");
     167    JLabel sortingLabel = new JLabel("Filter by e-values:  ");
    163168    sortingLabel.setBackground(new java.awt.Color(255, 255, 255));
    164169    sortingPanel.add(sortingLabel);
    165170   
    166     ascendingButton = new JRadioButton("ascending", true);
    167     ascendingButton.setActionCommand("ascending");
    168     ascendingButton.addActionListener(listener);
    169     ascendingButton.setBackground(new java.awt.Color(255, 255, 255));
    170     sortingPanel.add(ascendingButton);
    171    
    172     descendingButton = new JRadioButton("descending");
    173     descendingButton.setActionCommand("descending");
    174     descendingButton.addActionListener(listener);
    175     descendingButton.setBackground(new java.awt.Color(255, 255, 255));
    176     sortingPanel.add(descendingButton);
     171    proteinsButton = new JRadioButton("proteins", true);
     172    proteinsButton.setActionCommand("proteins");
     173    proteinsButton.addActionListener(listener);
     174    proteinsButton.setBackground(new java.awt.Color(255, 255, 255));
     175    sortingPanel.add(proteinsButton);
     176   
     177    peptidesButton = new JRadioButton("peptides and proteins");
     178    peptidesButton.setActionCommand("peptides");
     179    peptidesButton.addActionListener(listener);
     180    peptidesButton.setBackground(new java.awt.Color(255, 255, 255));
     181    sortingPanel.add(peptidesButton);
    177182     
    178183    ButtonGroup bg = new ButtonGroup();
    179     bg.add(ascendingButton);
    180     bg.add(descendingButton);
     184    bg.add(proteinsButton);
     185    bg.add(peptidesButton);
    181186   
    182187    main.add(sortingPanel);
    183188    /** End of the sorting panel */
    184189
     190    /**  The cut off panel */
     191    JPanel cutOffPanel = new JPanel();
     192    cutOffPanel.setBackground(new java.awt.Color(255, 255, 255));
     193   
     194    cutOffCheckBox = new JCheckBox("Cut off e-values above");
     195    cutOffCheckBox.setActionCommand("cut off");
     196    cutOffCheckBox.addActionListener(listener);
     197    cutOffCheckBox.setBackground(new java.awt.Color(255, 255, 255));
     198    cutOffPanel.add(cutOffCheckBox);
     199   
     200    cutOffSpinner = new JSpinner(new SpinnerNumberModel(0.05, 0.0, 1.0, 0.001)); 
     201    cutOffSpinner.setPreferredSize(new Dimension(48, 20));
     202    cutOffSpinner.setEnabled(false);
     203    cutOffSpinner.setBackground(new java.awt.Color(255, 255, 255));
     204    cutOffPanel.add(cutOffSpinner);
     205   
     206    main.add(cutOffPanel);
     207    /** End of the cut off panel */
    185208   
    186209   
     
    204227    /** End of date panel */
    205228   
    206    
    207     /**  The cut off panel */
    208     JPanel cutOffPanel = new JPanel();
    209     cutOffPanel.setBackground(new java.awt.Color(255, 255, 255));
    210    
    211     cutOffCheckBox = new JCheckBox("Cut off e-values");
    212     cutOffCheckBox.setActionCommand("cut off");
    213     cutOffCheckBox.addActionListener(listener);
    214     cutOffCheckBox.setBackground(new java.awt.Color(255, 255, 255));
    215     cutOffPanel.add(cutOffCheckBox);
    216    
    217     aboveButton = new JRadioButton("above", true);
    218     aboveButton.setEnabled(false);
    219     aboveButton.setActionCommand("above");
    220     aboveButton.addActionListener(listener);
    221     aboveButton.setBackground(new java.awt.Color(255, 255, 255));
    222     cutOffPanel.add(aboveButton);
    223    
    224     belowButton = new JRadioButton("below");
    225     belowButton.setEnabled(false);
    226     belowButton.setActionCommand("below");
    227     belowButton.addActionListener(listener);
    228     belowButton.setBackground(new java.awt.Color(255, 255, 255));
    229     cutOffPanel.add(belowButton);
    230    
    231     ButtonGroup bg2 = new ButtonGroup();
    232     bg2.add(aboveButton);
    233     bg2.add(belowButton);
    234    
    235     cutOffSpinner = new JSpinner(new SpinnerNumberModel(0.05, 0.0, 1.0, 0.001)); 
    236     cutOffSpinner.setPreferredSize(new Dimension(48, 20));
    237     cutOffSpinner.setEnabled(false);
    238     cutOffSpinner.setBackground(new java.awt.Color(255, 255, 255));
    239     cutOffPanel.add(cutOffSpinner);
    240    
    241     main.add(cutOffPanel);
    242     /** End of the cut off panel */
     229    /** The score type panel */
     230    JPanel scoreTypePanel = new JPanel();
     231    scoreTypePanel.setBackground(new java.awt.Color(255, 255, 255));
     232   
     233    scoreTypeCheckBox = new JCheckBox("Limit to results from score types starting with");
     234    scoreTypeCheckBox.setActionCommand("score filter");
     235      scoreTypeCheckBox.addActionListener(listener);
     236      scoreTypeCheckBox.setBackground(new java.awt.Color(255, 255, 255));
     237    scoreTypePanel.add(scoreTypeCheckBox);
     238   
     239    scoreTypeText = new JTextField("Mascot");
     240    scoreTypeText.setEnabled(false);
     241    scoreTypeText.setBackground(new java.awt.Color(255, 255, 255));
     242    scoreTypeText.setPreferredSize(new Dimension(100, 20));
     243    scoreTypePanel.add(scoreTypeText);
     244   
     245    main.add(scoreTypePanel);
     246    /** End of score type panel */
     247   
     248   
    243249
    244250   
     
    259265 
    260266  /** Gui components */
    261   private JCheckBox dateCheckBox, cutOffCheckBox, rankingCheckBox;
    262   private JRadioButton aboveButton, belowButton, ascendingButton, descendingButton;
     267  private JCheckBox dateCheckBox, cutOffCheckBox, rankingCheckBox, scoreTypeCheckBox;
     268  private JRadioButton proteinsButton, peptidesButton;
    263269  private JSpinner cutOffSpinner;
    264   private JTextField dateText,reverseText;
     270  private JTextField dateText,reverseText,scoreTypeText;
    265271}
  • trunk/src/org/proteios/query/ProteinHitsReportQuery.java

    r1525 r1528  
    1515// along with this program; if not, write to the Free Software
    1616// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
    17 
    1817package org.proteios.query;
    1918
     
    2928import java.util.Map;
    3029import java.util.HashMap;
    31 
    3230import org.proteios.core.SQLEvictConnection;
    3331import org.proteios.core.SQLConnection;
    34 
    3532import org.proteios.core.Element;
    3633import org.proteios.core.element.Gel;
     
    5350
    5451/**
    55   This class implements a query against a gel, and returns a report with
    56   info about the protein hits from that gel.
    57 
    58   @author Linus Göransson
    59 
    60 */
     52 * This class implements a query against a gel, and returns a report with info
     53 * about the protein hits from that gel.
     54 *
     55 * @author Linus Göransson
     56 */
    6157public class ProteinHitsReportQuery
    62   extends Query
     58    extends Query
    6359{
    6460  public ProteinHitsReportQuery()
     
    6965
    7066  /**
    71   * Executable if the object we query from is either Gel1D or Gel2D (i.e.
    72   * instanceof Gel) and all parameters set.
    73   *
    74   * @return true if query is executable.
    75   */
     67   * Executable if the object we query from is either Gel1D or Gel2D (i.e.
     68   * instanceof Gel) and all parameters set.
     69   *
     70   * @return true if query is executable.
     71   */
    7672  public boolean isExecutable()
    7773  {
     
    8177
    8278  /**
    83   * Set query origin and set executable if Gel.
    84   *
    85   * @param origin The gel that is being queried.
    86   * @param parent The query object's parent - null is OK.
    87   */
     79   * Set query origin and set executable if Gel.
     80   *
     81   * @param origin The gel that is being queried.
     82   * @param parent The query object's parent - null is OK.
     83   */
    8884  public void setQueryOrigin(Object queryObject, Object parentObject)
    8985  {
     
    9591  /** Once all parameters needed to run the query have been supplied. */
    9692  public QueryResult execute()
    97     throws QueryException
     93      throws QueryException
    9894  {
    9995    if (executable == false)
    10096    {
    101       throw new QueryException("Unable to execute " + query_name + " from: " + queryObject);
     97      throw new QueryException(
     98        "Unable to execute " + query_name + " from: " + queryObject);
    10299    }
    103100    resultSet = getResult();
    104     ProteinHitsReportQueryResult result = new ProteinHitsReportQueryResult(resultSet);
     101    ProteinHitsReportQueryResult result = new ProteinHitsReportQueryResult(
     102      resultSet);
    105103    result.setGelId(gelId);
    106104    result.setInfo(info);
    107105    return result;
    108106  }
    109  
    110  
     107
     108
    111109  /**
    112     Will exctract info from the proteios data structure and create
    113     a TreeSet containing sorted ResultRow objects.
    114   */
     110   * Will exctract info from the proteios data structure and create a TreeSet
     111   * containing sorted ResultRow objects.
     112   */
    115113  private Set getResult()
    116     throws QueryException
    117   {
    118     Set result = new TreeSet();
    119     Gel gel = (Gel)queryObject;
     114      throws QueryException
     115  {
     116    List result = new ArrayList();
     117    Gel gel = (Gel) queryObject;
    120118    gelId = gel.getGel_id();
    121    
     119    int firstproteinrow = 0;
     120    int lastproteinrow = 0;
     121    boolean foundproteins;
     122    String gel_autoid = Long.toString(gel.getAuto_id());
    122123    try
    123124    {
    124       // Iterate through all the spots and find assosciated mzData elements
     125      // Iterate through all the spots and find assosciated mzData
     126      // elements
    125127      GelItem currentGelItem;
    126       Map attributes=new HashMap();
    127       dbconnection=new SQLEvictConnection((SQLConnection) gel.getDataConnection());
     128      Map attributes = new HashMap();
     129      dbconnection = new SQLEvictConnection((SQLConnection) gel
     130        .getDataConnection());
    128131      dbconnection.beginTransaction();
    129       List spotList = null;
    130 
     132      List<GelItem> spotList = null;
    131133      // Gel is either Gel1D or Gel2D with Band or Spot respectively.
    132134      if (gel instanceof Gel1D)
    133135      {
    134         attributes.put("gel1D.gel_id",gelId);
    135         spotList = dbconnection.getElements("Band",attributes);
     136        attributes.put("gel1D.auto_id", gel_autoid);
     137        spotList = dbconnection.getElements("Band", attributes);
    136138      }
    137139      else if (gel instanceof Gel2D)
    138140      {
    139         attributes.put("gel2D.gel_id",gelId);
    140         spotList = dbconnection.getElements("Spot",attributes);
    141       }
    142 
     141        attributes.put("gel2D.auto_id", gel_autoid);
     142        spotList = dbconnection.getElements("Spot", attributes);
     143      }
    143144      if (spotList == null || spotList.isEmpty())
    144145      {
    145         throw new QueryException("There are no spot elements associated with this gel.");
    146       }
    147       //System.out.println("Spots:"+spotList.size());
    148       Iterator spotIter = spotList.iterator();
     146        throw new QueryException(
     147          "There are no spot elements associated with this gel.");
     148      }
     149      // System.out.println("Spots:"+spotList.size());
     150      // the following is used when querying for peptides:
     151      List<String> scoretypes = new ArrayList<String>();
     152      scoretypes.add(new String("Tandem hyperscore"));
     153      scoretypes.add(new String("Mascot peptide score"));
     154      Iterator<String> scoretypesit = scoretypes.iterator();
     155      if (getScoreTypeFilter() != null)
     156      {
     157        while (scoretypesit.hasNext())
     158        {
     159          String sct = scoretypesit.next();
     160          if (!sct.startsWith(
     161            getScoreTypeFilter()))
     162          {
     163            scoretypesit.remove();
     164          }
     165        }
     166      }
     167      // We want the spots sorted
     168      SortedSet<GelItem> spotSet = new TreeSet<GelItem>(spotList);
     169      Iterator<GelItem> spotIter = spotSet.iterator();
    149170      while (spotIter.hasNext())
    150171      {
    151         currentGelItem = (GelItem)spotIter.next();
    152         // Now find all mzData elements belonging to this spot and put them in a list.
    153         List mzDataList = new ArrayList(currentGelItem.getMzDataCollection());
    154         // Now extract the DBSearch elements for each of the mzData elements in the list.
    155         List dBSearchList = new ArrayList();
    156         Iterator mzDataIter = mzDataList.iterator();
    157         while (mzDataIter.hasNext())
     172        currentGelItem = (GelItem) spotIter.next();
     173        System.out.println("Spot:" + currentGelItem.getId());
     174        firstproteinrow = result.size();
     175        // Now find all the results that pass the limit. First get
     176        // proteins
     177        String query_string = "from MoleculeIdentifier mi where ";
     178        if (gel instanceof Gel2D)
    158179        {
    159           MzData currentMzData = (MzData)mzDataIter.next();
    160          
    161           // Mascot reporting:
    162           List mzAnalysisList = new ArrayList(currentMzData.getMzAnalysisCollection());
    163           List specList = new ArrayList(currentMzData.getSpectrumListCollection());
    164           List spectra = new ArrayList();
    165           if (!specList.isEmpty())
     180          query_string += " mi.polyPeptide.identificationHypothesis.result.mzAnalysis.mzData.spot.auto_id='" + currentGelItem
     181            .getAuto_id() + "'";
     182        }
     183        else
     184        {
     185          query_string += " mi.polyPeptide.identificationHypothesis.result.mzAnalysis.mzData.band.auto_id='" + currentGelItem
     186            .getAuto_id() + "'";
     187        }
     188        if (getCutOff() != null)
     189        {
     190          query_string += " and mi.polyPeptide.identificationHypothesis.e_value<" + Double
     191            .toString(this.getCutOff());
     192        }
     193        foundproteins = false;
     194        Iterator miIt = dbconnection.getQueryResult(query_string)
     195          .iterator();
     196        while (miIt.hasNext())
     197        {
     198          foundproteins = true;
     199          boolean filteraway = false;
     200          MoleculeIdentifier currentMolecule = (MoleculeIdentifier) miIt
     201            .next();
     202          IdentificationHypothesis currentHypothesis = currentMolecule
     203            .getPolyPeptide().getIdentificationHypothesis();
     204          Result currentResult = currentHypothesis.getResult();
     205          MzAnalysis currentAnalysis = currentResult.getMzAnalysis();
     206          MzData currentMzData = currentAnalysis.getMzData();
     207          /*
     208           * List specList = new
     209           * ArrayList(currentMzData.getSpectrumListCollection());
     210           * List spectra = new ArrayList(); if (!specList.isEmpty()) {
     211           * spectra = new ArrayList(((SpectrumList)
     212           * specList.get(0)).getSpectrumCollection()); }
     213           */
     214          long spectrumID = currentResult.getSpectrumId();
     215          ResultRow row = new ResultRow();
     216          // Expect the id_date to be in standard XML dateTime format.
     217          try
    166218          {
    167             spectra = new ArrayList(((SpectrumList) specList.get(0)).getSpectrumCollection());
     219            row.dBSearchId = dfXML.parse(currentAnalysis
     220              .getAnalysisTime());
     221            if (getDate() != null)
     222            {
     223              if (!dfXML.format(row.dBSearchId).startsWith(
     224                getDate()))
     225              {
     226                filteraway = true;
     227              }
     228            }
    168229          }
    169           Iterator mzAnalysisListIterator = mzAnalysisList.iterator();
    170           while (mzAnalysisListIterator.hasNext())
     230          catch (java.text.ParseException e)
    171231          {
    172             MzAnalysis currentAnalysis = (MzAnalysis)mzAnalysisListIterator.next();
    173             List resultList = new ArrayList(currentAnalysis.getResultCollection());
    174             Iterator resultListIterator = resultList.iterator();
    175             while (resultListIterator.hasNext())
    176             {
    177               Result currentResult = (Result) resultListIterator.next();
    178               long spectrumID = currentResult.getSpectrumId();
    179               List hypothesisList = new ArrayList(currentResult.getIdentificationHypothesisCollection());
    180               Iterator hypothesisIterator = hypothesisList.iterator();
    181               while (hypothesisIterator.hasNext())
     232            throw new org.proteios.core.CoreException(
     233              "Could not parse id_date: " + currentAnalysis
     234                .getAnalysisTime() + " is not a valid XML dateTime format.");
     235          }
     236          row.spotId = (int) currentGelItem.getId();
     237          row.MPId = currentMzData.getMPId();
     238          row.MPLabel = currentMzData.getMPLabel();
     239          row.MPTargetId = currentMzData.getTarget_id();
     240          row.MPTargetPosition = currentMzData.getTarget_position();
     241          row.eValue = currentHypothesis.getE_value();
     242          row.score = currentHypothesis.getScore();
     243          row.score_type = currentHypothesis.getScore_type();
     244          if (getScoreTypeFilter() != null)
     245          {
     246            if (!row.score_type.startsWith(getScoreTypeFilter()))
     247            {
     248              filteraway = true;
     249            }
     250          }
     251          if (!filteraway)
     252          {
     253            row.proteinId = currentMolecule.getAccession_number();
     254            // For IPI entries we want to get rid of initial
     255            // IPI:
     256            if (row.proteinId.startsWith("IPI:"))
     257            {
     258              row.proteinId = row.proteinId.substring(4);
     259            }
     260            row.description = currentMolecule.getName();
     261            if (currentMolecule.getPredicted_mass() != null)
     262            {
     263              row.mw = currentMolecule.getPredicted_mass()
     264                .doubleValue();
     265            }
     266            if (currentMolecule.getPredicted_pI() != null)
     267            {
     268              row.pi = currentMolecule.getPredicted_pI()
     269                .doubleValue();
     270            }
     271            /*
     272             * and now try to find the corresponding spectrum if
     273             * piums score
     274             */
     275            if (row.score_type.startsWith("PIUMS"))
     276            {
     277              query_string = "from PeakList p where p.spectrum.spectrumList.mzData.auto_id='";
     278              query_string += "" + currentMzData.getAuto_id() + "'";
     279              Iterator peakListIt = dbconnection.getQueryResult(
     280                query_string).iterator();
     281              if (peakListIt.hasNext())
    182282              {
    183                 IdentificationHypothesis currentHypothesis = (IdentificationHypothesis) hypothesisIterator.next();
    184                 ResultRow row = new ResultRow(getDescending().booleanValue()); 
    185                 //Expect the id_date to be in standard XML dateTime format.
    186                 try
     283                PeakList currentMsPeakList = (PeakList) peakListIt
     284                  .next();
     285                boolean protonated = true;
     286                if (currentMsPeakList.getProtonated() == false)
    187287                {
    188                   row.dBSearchId = dfXML.parse(currentAnalysis.getAnalysisTime());
     288                  protonated = false;
    189289                }
    190                 catch (java.text.ParseException e)
     290                List hypothesisProperties = new ArrayList(
     291                  currentHypothesis
     292                    .getHypothesisPropertyCollection());
     293                int matches = 0;
     294                List peaks = new ArrayList(currentMsPeakList
     295                  .getPeakCollection());
     296                row.totalPeaks = peaks.size();
     297                // Calculate the square sum of all delta values
     298                double deltaSquareSum = 0;
     299                Iterator matchedMassIter = hypothesisProperties
     300                  .iterator();
     301                while (matchedMassIter.hasNext())
    191302                {
    192                   throw new org.proteios.core.CoreException("Could not parse id_date: " + currentAnalysis.getAnalysisTime() + " is not a valid XML dateTime format.");
    193                 }
    194                 row.spotId = (int) currentGelItem.getId();
    195                 row.MPId = currentGelItem.getMPId();
    196                 row.MPLabel = currentGelItem.getMPLabel();
    197                 row.MPTargetId = currentGelItem.getTarget_id();
    198                 row.MPTargetPosition = currentGelItem.getTarget_position();
    199                 row.eValue = currentHypothesis.getE_value();
    200                 row.score = currentHypothesis.getScore();
    201                 row.score_type = currentHypothesis.getScore_type();
    202                 List pplist = new ArrayList(currentHypothesis.getPolyPeptideCollection());
    203                 Iterator pplistIterator = pplist.iterator();
    204                 while (pplistIterator.hasNext())
    205                 {
    206                   PolyPeptide pp = (PolyPeptide) pplistIterator.next();
    207                   // The description will be the peptide sequence
    208                   row.description = pp.getSequence();
    209                   List pmlist  = new ArrayList(pp.getParentMoleculeCollection());
    210                   Iterator pmlistIterator = pmlist.iterator();
    211                   while (pmlistIterator.hasNext())         
    212                   {
    213                     // peptide
    214                     ParentMolecule pm = (ParentMolecule) pmlistIterator.next();
    215                     if (row.proteinId.length()>0)
     303                  HypothesisProperty currentMatchedMass = (HypothesisProperty) matchedMassIter
     304                    .next();
     305                  if (currentMatchedMass.getName()
     306                    .startsWith("Matched"))
     307                  {
     308                    matches++;
     309                    double predMass = Double
     310                      .valueOf(currentMatchedMass
     311                        .getValue());
     312                    // The matched masses are always stored
     313                    // as M and the peak list may be MH+
     314                    if (protonated)
    216315                    {
    217                       row.proteinId+=", ";
     316                      predMass += 1.00728;
    218317                    }
    219                     String acc = pm.getAccession_number();
    220                     // Get rid of initial IPI: for IPI entries
    221                     if (acc.startsWith("IPI:"))
     318                    Iterator peakIter = peaks.iterator();
     319                    Double smallestDiff = null;
     320                    // Iterate through the peak masses to
     321                    // find the one that best matches the
     322                    // predicted mass and calculate delta
     323                    // from that.
     324                    while (peakIter.hasNext())
    222325                    {
    223                       acc=acc.substring(4);
    224                       // And also other type accession numbers
    225                       if (acc.contains("|"))
     326                      Peak currentPeak = (Peak) peakIter
     327                        .next();
     328                      double mass = currentPeak.getMass();
     329                      double diff = Math
     330                        .abs(mass - predMass);
     331                      if (smallestDiff != null)
    226332                      {
    227                         acc=acc.substring(0,acc.indexOf('|'));
    228                       }
    229                     }
    230                     // Add all matching protein accessions on the same line
    231                     row.proteinId += acc;
    232                     // Add variable modifications to the sequence description
    233                     List modlist = new ArrayList(pp.getUserModificationCollection());
    234                     Iterator moditerator = modlist.iterator();
    235                     while (moditerator.hasNext())
    236                     {
    237                       row.description+=" , "+((UserModification) moditerator.next()).getName();
    238                     }
    239                     dbconnection.evictElement(pm);
    240                   }
    241                   pmlist  = new ArrayList(pp.getMoleculeIdentifierCollection());
    242                   pmlistIterator = pmlist.iterator();
    243                   while (pmlistIterator.hasNext())         
    244                   {
    245                     // protein
    246                     MoleculeIdentifier mi = (MoleculeIdentifier) pmlistIterator.next();
    247                     row.proteinId = mi.getAccession_number();
    248                     // For IPI entries we want to get rid of initial IPI:
    249                     if (row.proteinId.startsWith("IPI:"))
    250                     {
    251                       row.proteinId=row.proteinId.substring(4);
    252                     }
    253                     row.description = mi.getName();
    254                     if (mi.getPredicted_mass() != null)
    255                     {
    256                       row.mw = mi.getPredicted_mass().doubleValue();
    257                     }
    258                     if (mi.getPredicted_pI() != null)
    259                     {
    260                       row.pi = mi.getPredicted_pI().doubleValue();
    261                     }
    262                     dbconnection.evictElement(mi);
    263                   }
    264                   dbconnection.evictElement(pp);
    265                 }
    266                 /* and now try to find the corresponding spectrum if piums score
    267                  */
    268                 if (row.score_type.startsWith("PIUMS"))
    269                 {
    270                   Iterator spectrumIterator = spectra.iterator();
    271                   while (spectrumIterator.hasNext())
    272                   {
    273                     Spectrum currentSpectrum = (Spectrum)spectrumIterator.next();
    274                     // Iterate through the peaklists and put all
    275                     List msPeakListList = new ArrayList(currentSpectrum.getPeakListCollection());
    276                     if (!msPeakListList.isEmpty() && currentSpectrum.getId()==spectrumID)
    277                     {
    278                       PeakList currentMsPeakList = (PeakList) msPeakListList.get(0);
    279                       boolean protonated=true;
    280                       if (currentMsPeakList.getProtonated()==false)
    281                       {
    282                         protonated=false;
    283                       }
    284                       List hypothesisProperties = new ArrayList(currentHypothesis.getHypothesisPropertyCollection());
    285                       int matches=0;
    286                       List peaks = new ArrayList(currentMsPeakList.getPeakCollection());
    287                       row.totalPeaks = peaks.size();               
    288                       // Calculate the square sum of all delta values
    289                       double deltaSquareSum = 0;
    290                       Iterator matchedMassIter = hypothesisProperties.iterator();
    291                       while (matchedMassIter.hasNext())
    292                       {
    293                         HypothesisProperty currentMatchedMass = (HypothesisProperty)matchedMassIter.next();
    294                         if (currentMatchedMass.getName().startsWith("Matched"))
     333                        if (diff < smallestDiff)
    295334                        {
    296                           matches++;
    297                           double predMass = Double.valueOf(currentMatchedMass.getValue());
    298                           // The matched masses are always stored as M and the peak list may be MH+
    299                           if (protonated)
    300                           {
    301                             predMass+=1.00728;
    302                           }
    303                           Iterator peakIter = peaks.iterator();
    304                           Double smallestDiff = null;
    305                           // Iterate through the peak masses to find the one that best matches the
    306                           // predicted mass and calculate delta from that.
    307                           while (peakIter.hasNext())
    308                           {
    309                             Peak currentPeak=(Peak) peakIter.next();
    310                             double mass = currentPeak.getMass();
    311                             double diff = Math.abs(mass - predMass);
    312                             if (smallestDiff != null)
    313                             {
    314                               if (diff < smallestDiff)
    315                               {
    316                                 smallestDiff = diff;
    317                               }
    318                             }
    319                             else
    320                             {
    321                               smallestDiff = diff;
    322                             }
    323                             dbconnection.evictElement(currentPeak);
    324                           }
    325                           double delta = (smallestDiff/predMass)*1000000;
    326                           deltaSquareSum += Math.pow(delta, 2);
     335                          smallestDiff = diff;
    327336                        }
    328                         else if (currentMatchedMass.getName().equals("sequence_coverage"))
    329                         {
    330                           row.coverage = Double.valueOf(currentMatchedMass.getValue());
    331                         }
    332                         dbconnection.evictElement(currentMatchedMass);
    333                       }
    334                       row.rms = Math.sqrt(deltaSquareSum/matches);
    335                       row.matchedPeaks = matches;
    336                     }
    337                   }
    338                 }
    339                 else if (row.score_type.startsWith("Mascot peptide") || row.score_type.startsWith("Tandem hyper"))
    340                 {
    341                   List hypothesisProperties = new ArrayList(currentHypothesis.getHypothesisPropertyCollection());
    342                   Iterator hpi = hypothesisProperties.iterator();
    343                   while (hpi.hasNext())
    344                   {
    345                     HypothesisProperty hp=(HypothesisProperty) hpi.next();
    346                     // Mascot and Tandem
    347                     if (hp.getName().equals("delta"))
    348                     {
    349                       row.delta = Double.valueOf(hp.getValue());
    350                     }
    351                     // Mascot
    352                     else if (hp.getName().equals("exp_mr"))
    353                     {
    354                       row.exp_mr = Double.valueOf(hp.getValue());
    355                     }
    356                     // Mascot
    357                     else if (hp.getName().equals("exp_z"))
    358                     {
    359                       row.exp_z = Integer.valueOf(hp.getValue());
    360                     }
    361                     dbconnection.evictElement(hp);
    362                   }
    363                  
    364                   Iterator spectrumIterator = spectra.iterator();
    365                   boolean specFound=false;
    366                   while (spectrumIterator.hasNext() && !specFound)
    367                   {
    368                     Spectrum currentSpectrum = (Spectrum)spectrumIterator.next();
    369                     // Iterate through the peaklists and put all
    370                     List msPeakListList = new ArrayList(currentSpectrum.getPeakListCollection());
    371                     if (!msPeakListList.isEmpty() && currentSpectrum.getId()==spectrumID)
    372                     {
    373                       specFound=true;
    374                       PeakList currentMsPeakList = (PeakList) msPeakListList.get(0);
    375                       if (currentMsPeakList.getDescription().startsWith("total intensity"))
    376                       {
    377                         row.totalIntensity=Double.valueOf(currentMsPeakList.getDescription().substring(16));
    378337                      }
    379338                      else
    380339                      {
    381                         double totint=0;
    382                         List peaks=new ArrayList(currentMsPeakList.getPeakCollection());
    383                         Iterator peakiterator=peaks.iterator();
    384                         while (peakiterator.hasNext())
    385                         {
    386                           Peak currentpeak=(Peak) peakiterator.next();
    387                           totint+=currentpeak.getMass();
    388                           dbconnection.evictElement(currentpeak);
    389                         }
    390                         row.totalIntensity=totint;
     340                        smallestDiff = diff;
    391341                      }
     342                      dbconnection
     343                        .evictElement(currentPeak);
    392344                    }
    393                     dbconnection.evictElement(currentSpectrum);
    394                   }
     345                    double delta = (smallestDiff / predMass) * 1000000;
     346                    deltaSquareSum += Math.pow(delta, 2);
     347                  }
     348                  else if (currentMatchedMass.getName()
     349                    .equals("sequence_coverage"))
     350                  {
     351                    row.coverage = Double
     352                      .valueOf(currentMatchedMass
     353                        .getValue());
     354                  }
     355                  dbconnection
     356                    .evictElement(currentMatchedMass);
    395357                }
    396                 // add the result!
     358                row.rms = Math.sqrt(deltaSquareSum / matches);
     359                row.matchedPeaks = matches;
     360              }
     361            }
     362              // add the result!
     363              result.add(row);
     364              lastproteinrow = result.size() - 1;
     365          }
     366          dbconnection.evictElement(currentMolecule);
     367          dbconnection.evictElement(currentHypothesis);
     368          dbconnection.evictElement(currentResult);
     369          dbconnection.evictElement(currentAnalysis);
     370          dbconnection.evictElement(currentMzData);
     371        }
     372        // Now get the peptide results for the spot
     373        if (foundproteins || peptideFilter)
     374        {
     375          List peptides = new ArrayList();
     376          scoretypesit = scoretypes.iterator();
     377          while (scoretypesit.hasNext())
     378          {
     379            query_string = "from IdentificationHypothesis ih where ih.score_type='"+scoretypesit.next();
     380            query_string += "' and ih.result.mzAnalysis.mzData.spot.auto_id='" + currentGelItem
     381              .getAuto_id() + "'";
     382            if (getCutOff() != null && peptideFilter)
     383            {
     384              query_string += " and e_value<" + Double
     385                .toString(this.getCutOff());
     386            }
     387            peptides.addAll(dbconnection
     388              .getQueryResult(query_string));
     389          }
     390          Iterator pepit = peptides.iterator();
     391          while (pepit.hasNext())
     392          {
     393            IdentificationHypothesis currentHypothesis = (IdentificationHypothesis) pepit
     394              .next();
     395            Result currentResult = currentHypothesis.getResult();
     396            MzAnalysis currentAnalysis = currentResult
     397              .getMzAnalysis();
     398            MzData currentMzData = currentAnalysis.getMzData();
     399            long spectrumID = currentResult.getSpectrumId();
     400            boolean userow = peptideFilter;
     401            boolean filteraway = false;
     402            ResultRow row = new ResultRow();
     403            // Expect the id_date to be in standard XML dateTime
     404            // format.
     405            try
     406            {
     407              row.dBSearchId = dfXML.parse(currentAnalysis
     408                .getAnalysisTime());
     409              if (getDate() != null)
     410              {
     411                if (!dfXML.format(row.dBSearchId).startsWith(
     412                  getDate()))
     413                {
     414                  filteraway = true;
     415                }
     416              }
     417            }
     418            catch (java.text.ParseException e)
     419            {
     420              throw new org.proteios.core.CoreException(
     421                "Could not parse id_date: " + currentAnalysis
     422                  .getAnalysisTime() + " is not a valid XML dateTime format.");
     423            }
     424            row.spotId = (int) currentGelItem.getId();
     425            row.MPId = currentMzData.getMPId();
     426            row.MPLabel = currentMzData.getMPLabel();
     427            row.MPTargetId = currentMzData.getTarget_id();
     428            row.MPTargetPosition = currentMzData
     429              .getTarget_position();
     430            row.eValue = currentHypothesis.getE_value();
     431            row.score = currentHypothesis.getScore();
     432            row.score_type = currentHypothesis.getScore_type();
     433            if (getScoreTypeFilter() != null)
     434            {
     435              if (!row.score_type
     436                .startsWith(getScoreTypeFilter()))
     437              {
     438                filteraway = true;
     439              }
     440            }
     441            if (!filteraway)
     442            {
     443              List pplist = new ArrayList(currentHypothesis
     444                .getPolyPeptideCollection());
     445              Iterator pplistIterator = pplist.iterator();
     446              while (pplistIterator.hasNext())
     447              {
     448                PolyPeptide pp = (PolyPeptide) pplistIterator
     449                  .next();
     450                // The description will be the peptide sequence
     451                row.description = pp.getSequence();
     452                List pmlist = new ArrayList(pp
     453                  .getParentMoleculeCollection());
     454                Iterator pmlistIterator = pmlist.iterator();
     455                while (pmlistIterator.hasNext())
     456                { // peptide if parent molcule
     457                  ParentMolecule pm = (ParentMolecule) pmlistIterator
     458                    .next();
     459                  if (row.proteinId.length() > 0)
     460                  {
     461                    row.proteinId += ", ";
     462                  }
     463                  String acc = pm.getAccession_number();
     464                  // Get rid of initial IPI: for IPI entries
     465                  if (acc.startsWith("IPI:"))
     466                  {
     467                    acc = acc.substring(4);
     468                    // And also other type accession numbers
     469                    if (acc.contains("|"))
     470                    {
     471                      acc = acc.substring(0, acc
     472                        .indexOf('|'));
     473                    }
     474                  }
     475                  /*
     476                   * Add all matching protein accessions on
     477                   * the same line
     478                   */
     479                  row.proteinId += acc;
     480                  /*
     481                   * Add variable modifications to the
     482                   * sequence description
     483                   */
     484                  List modlist = new ArrayList(pp
     485                    .getUserModificationCollection());
     486                  Iterator moditerator = modlist.iterator();
     487                  while (moditerator.hasNext())
     488                  {
     489                    row.description += " , " + ((UserModification) moditerator
     490                      .next()).getName();
     491                  }
     492                  dbconnection.evictElement(pm);
     493                }
     494                dbconnection.evictElement(pp);
     495              }
     496              // Test if peptide included in significant hits
     497              String currentscore = row.score_type
     498                .substring(0, 5);
     499              if (!peptideFilter && result.size() > 0)
     500              {
     501                for (int l = firstproteinrow; l <= lastproteinrow; l++)
     502                {
     503                  ResultRow protRow = (ResultRow) result
     504                    .get(l);
     505                  String acc = protRow.proteinId;
     506                  if (acc.contains("|"))
     507                  {
     508                    acc = acc
     509                      .substring(0, acc.indexOf('|'));
     510                  }
     511                  if (row.proteinId.contains(acc) && protRow.score_type
     512                    .startsWith(currentscore))
     513                  {
     514                    userow = true;
     515                  }
     516                }
     517              }
     518              if (userow)
     519              {
     520                List hypothesisProperties = new ArrayList(
     521                  currentHypothesis
     522                    .getHypothesisPropertyCollection());
     523                Iterator hpi = hypothesisProperties.iterator();
     524                double tandem_calc_mh = 0;
     525                while (hpi.hasNext())
     526                {
     527                  HypothesisProperty hp = (HypothesisProperty) hpi
     528                    .next();
     529                  // Mascot and Tandem
     530                  if (hp.getName().equals("delta"))
     531                  {
     532                    row.delta = Double.valueOf(hp
     533                      .getValue());
     534                    if (tandem_calc_mh != 0)
     535                    {
     536                      row.exp_mr = tandem_calc_mh + row.delta - 1.00728;
     537                    }
     538                  }
     539                  // Mascot
     540                  else if (hp.getName().equals("exp_mr"))
     541                  {
     542                    row.exp_mr = Double.valueOf(hp
     543                      .getValue());
     544                  }
     545                  else if (hp.getName().equals("calc_mh"))
     546                  // Tandem
     547                  {
     548                    tandem_calc_mh = Double.valueOf(hp
     549                      .getValue());
     550                  }
     551                  // Mascot
     552                  else if (hp.getName().equals("exp_z"))
     553                  {
     554                    row.exp_z = Integer.valueOf(hp
     555                      .getValue());
     556                  }
     557                  dbconnection.evictElement(hp);
     558                }
     559                query_string = "from Spectrum s where s.spectrumList.mzData.auto_id='" + currentMzData
     560                  .getAuto_id() + "'";
     561                query_string += " and id='" + spectrumID + "'";
     562                Iterator specit = dbconnection.getQueryResult(
     563                  query_string).iterator();
     564                if (specit.hasNext())
     565                {
     566                  Spectrum currentSpectrum = (Spectrum) specit
     567                    .next();
     568                  Iterator pklit = currentSpectrum
     569                    .getPeakListCollection().iterator();
     570                  if (pklit.hasNext())
     571                  {
     572                    PeakList currentMsPeakList = (PeakList) pklit
     573                      .next();
     574                    if (currentMsPeakList.getDescription()
     575                      .startsWith("total intensity"))
     576                    {
     577                      row.totalIntensity = Double
     578                        .valueOf(currentMsPeakList
     579                          .getDescription()
     580                          .substring(16));
     581                    }
     582                    else
     583                    {
     584                      double totint = 0;
     585                      List peaks = new ArrayList(
     586                        currentMsPeakList
     587                          .getPeakCollection());
     588                      Iterator peakiterator = peaks
     589                        .iterator();
     590                      while (peakiterator.hasNext())
     591                      {
     592                        Peak currentpeak = (Peak) peakiterator
     593                          .next();
     594                        totint += currentpeak.getMass();
     595                        dbconnection
     596                          .evictElement(currentpeak);
     597                      }
     598                      row.totalIntensity = totint;
     599                    }
     600                    dbconnection
     601                      .evictElement(currentMsPeakList);
     602                  }
     603                  dbconnection.evictElement(currentSpectrum);
     604                }
     605                // Test if tandem or mascot
     606                currentscore = row.score_type.substring(0, 5);
     607                if (result.size() > 0)
     608                {
     609                  for (int l = firstproteinrow; l <= lastproteinrow; l++)
     610                  {
     611                    ResultRow protRow = (ResultRow) result
     612                      .get(l);
     613                    String acc = protRow.proteinId;
     614                    // And also other type accession numbers
     615                    if (acc.contains("|"))
     616                    {
     617                      acc = acc.substring(0, acc
     618                        .indexOf('|'));
     619                    }
     620                    if (row.proteinId.contains(acc) && protRow.score_type
     621                      .startsWith(currentscore))
     622                    {
     623                      protRow.totalIntensity += row.totalIntensity;
     624                      protRow.matchedPeaks++;
     625                      protRow.rms += Math
     626                        .pow(
     627                          (row.delta / row.exp_mr * 1000000),
     628                          2);
     629                    }
     630                  }
     631                }
     632                // Only use the rows for peptides that where
     633                // found
     634                // in
     635                // proteins
     636                // if protein filter, otherwise use all
    397637                result.add(row);
    398                 dbconnection.evictElement(currentHypothesis);
    399638              }
    400               dbconnection.evictElement(currentResult);
    401             }
     639            }
     640            dbconnection.evictElement(currentHypothesis);
     641            dbconnection.evictElement(currentResult);
    402642            dbconnection.evictElement(currentAnalysis);
     643            dbconnection.evictElement(currentMzData);
    403644          }
    404           dbconnection.evictElement(currentMzData);
    405           mzDataIter.remove();
    406645        }
    407646        dbconnection.evictElement(currentGelItem);
     
    415654      throw new QueryException("Error building report: " + e.getMessage());
    416655    }
    417 
    418     /**
    419       Now that we have created the result set we want to filter it according
    420       to the filter parameters.
    421     */
     656    // Now the rms values for the mascor and tandem protein scores need to
     657    // be adjusted, since
     658    // they are now the delta square sum
     659    for (int j = 0; j < result.size(); j++)
     660    {
     661      ResultRow thisRow = (ResultRow) result.get(j);
     662      if (thisRow.score_type.startsWith("Mascot prot") || thisRow.score_type
     663        .startsWith("Tandem prot"))
     664      {
     665        thisRow.rms = Math.sqrt(thisRow.rms / thisRow.matchedPeaks);
     666      }
     667    }
     668    // We want to count how many hits are in the reverse DB. Count for
     669    // each score type.
    422670    Iterator i = result.iterator();
    423     boolean remove;
     671    Map<String, Integer> score_types = new HashMap<String, Integer>();
    424672    while (i.hasNext())
    425673    {
    426       ResultRow currentRow = (ResultRow)i.next();
    427       remove = false;
    428       // Start by filter by date
    429       if (getDate() != null)
    430       {
    431         if (!dfXML.format(currentRow.dBSearchId).startsWith(getDate()))
    432         {
    433           remove = true;
    434         }
    435       }
    436       // Filter by cutoff
    437       if (getCutOff() != null)
    438       {
    439         if (getCutOff().doubleValue() > currentRow.eValue && !isCutOffAbove().booleanValue())
    440         {
    441           remove = true;
    442         }
    443         if (getCutOff().doubleValue() < currentRow.eValue && isCutOffAbove().booleanValue() && currentRow.eValue!=1000)
    444         {
    445           remove = true;
    446         }
    447       }
    448      
    449       // If flagged for removal, remove from result.
    450       if (remove)
    451       {
    452         i.remove();
    453       }
    454     }
    455    
    456     // Now we want to add intensities and count peptides for proteins.
    457     // Create a list for the result rows.
    458     List resultList = new ArrayList(result);
    459     // The first entry is always included in the result.
    460     ResultRow lastRow=(ResultRow)resultList.get(0);
    461     int firstProteinInSpot = 0;
    462     int lastProteinInSpot = 0;
    463     // Iterate through the result list. Add proteins to list first.
    464     // The protein scores are found before the peptide scores
    465     for (int j = 0; j < resultList.size(); j++)
    466     {
    467       ResultRow thisRow = (ResultRow)resultList.get(j);
    468       // If the hits belong to the same dbsearch and spot AND are proteins then just add them to new list
    469       if (thisRow.score_type.startsWith("Mascot pep"))
    470       {
    471         for (int l=firstProteinInSpot;l<=lastProteinInSpot;l++)
    472         {
    473           ResultRow protRow=(ResultRow) resultList.get(l);
    474           if (thisRow.proteinId.contains(protRow.proteinId) && protRow.score_type.startsWith("Mascot prot"))
    475           {
    476             protRow.totalIntensity+=thisRow.totalIntensity;
    477             protRow.matchedPeaks++;
    478             protRow.rms+=Math.pow((thisRow.delta/thisRow.exp_mr*1000000), 2);
    479           }
    480         }
    481       }
    482       else if (thisRow.score_type.startsWith("Mascot prot"))
    483       {
    484         lastProteinInSpot=j;
    485       }
    486       if (!thisRow.dBSearchId.equals(lastRow.dBSearchId) || thisRow.spotId!=lastRow.spotId)
    487       {
    488         // We are at a new spot
    489         firstProteinInSpot=j;
    490         lastProteinInSpot=j;
    491       }
    492       lastRow=thisRow;
    493     }
    494    
    495     // Now the rms values for Mascot proteins need to be adjusted, since they are now the delta square sum
    496     for (int j = 0; j < resultList.size(); j++)
    497     {
    498       ResultRow thisRow = (ResultRow)resultList.get(j);
    499       if (thisRow.score_type.startsWith("Mascot prot"))
    500       {
    501         thisRow.rms = Math.sqrt(thisRow.rms/thisRow.matchedPeaks);
    502       }
    503     }
    504     result=new TreeSet(resultList);
    505 
    506     // Now remove the Mascot peptides that were retained previously
    507     i = result.iterator();
    508     while (i.hasNext())
    509     {
    510       ResultRow currentRow = (ResultRow)i.next();
    511       remove = false;
    512       // Filter by cutoff
    513       if (getCutOff() != null)
    514       {
    515         if (currentRow.eValue==1000 && isCutOffAbove().booleanValue())
    516         {
    517           i.remove();
    518         }
    519       }
    520     }
    521    
    522     // Now we want to make a list with the X highest ranking hits for a specified dbsearch/spot
    523     // combination. Only done if we have specified a hitsPerGelItem and if the result set is > 1.
    524     Set rankedResult = new TreeSet();
    525 /*  This has not been tested:   
    526     if ((hitsPerGelItem > 0) && (result.size() > 0))
    527     {
    528       // Create a list for the result rows.
    529       resultList = new ArrayList(result);
    530       // The first entry is always included in the result.
    531       rankedResult.add(resultList.get(0));
    532       // Helps us to keep track of the current ranking.
    533       int countRankingFromHere = 0;
    534       // Begin the iteration from the second entry, then iterate through the entire
    535       // list, adding the X highest ranking hits to the rankedResult set.
    536       for (int j = 1; j < resultList.size(); j++)
    537       {
    538         ResultRow thisRow = (ResultRow)resultList.get(j);
    539         lastRow = (ResultRow)resultList.get(j-1);
    540         // If the hits belong to the same dbsearch and spot AND we have not exceeded the specified number of
    541         // hits per spot, add the row to the rankedResult set.
    542         if ((thisRow.dBSearchId.equals(lastRow.dBSearchId)) && thisRow.spotId==lastRow.spotId)
    543         {
    544           if ((j - countRankingFromHere) < getHitsPerGelItem().intValue())
    545           rankedResult.add(thisRow);
    546          
    547         }
    548         // Otherwise add it and reset countRankingFromHere to the current index.
    549         else
    550         {
    551           rankedResult.add(thisRow);
    552           countRankingFromHere = j;
    553         }
    554       }
    555     }
    556 */   
    557     if (rankedResult.isEmpty())
    558     {
    559       // We want to count how many hits are in the reverse DB. Count for each score type.
    560       i=result.iterator();
    561       Map<String,Integer> score_types=new HashMap<String,Integer>();
    562       while (i.hasNext())
    563       {
    564         ResultRow thisRow=(ResultRow) i.next();
    565         if (score_types.containsKey(thisRow.score_type))
    566         {
    567           Integer new_value=score_types.get(thisRow.score_type).intValue()+1;
    568           score_types.put(thisRow.score_type,new_value);
    569         }
    570         else
    571         {
    572           score_types.put(thisRow.score_type,1);
    573           score_types.put("Rev"+thisRow.score_type,new Integer(0));
    574         }
    575         if (thisRow.proteinId.startsWith(reverseText))
    576         {
    577           Integer new_value=score_types.get("Rev"+thisRow.score_type).intValue()+1;
    578           score_types.put("Rev"+thisRow.score_type,new_value);
    579         }
    580       }
    581       // Now put this into the info string
    582       Set<String> score_names=score_types.keySet();
    583       Iterator<String> it = score_names.iterator();
    584       while (it.hasNext())
    585       {
    586         String s=it.next();
    587         if (!s.startsWith("Rev"))
    588         {
    589           int rev=score_types.get("Rev"+s).intValue();
    590           int tot=score_types.get(s).intValue();
    591           info +="Of score type "+s+" there where "+rev+" reverse hits out of "+tot+" total hits.";
    592         }
    593       }
    594       return result;
    595     }
    596     else
    597     {
    598       return rankedResult;
    599     }
    600   }
    601  
     674      ResultRow thisRow = (ResultRow) i.next();
     675      if (score_types.containsKey(thisRow.score_type))
     676      {
     677        Integer new_value = score_types.get(thisRow.score_type)
     678          .intValue() + 1;
     679        score_types.put(thisRow.score_type, new_value);
     680      }
     681      else
     682      {
     683        score_types.put(thisRow.score_type, 1);
     684        score_types.put("Rev" + thisRow.score_type, new Integer(0));
     685      }
     686      if (thisRow.proteinId.startsWith(reverseText))
     687      {
     688        Integer new_value = score_types.get("Rev" + thisRow.score_type)
     689          .intValue() + 1;
     690        score_types.put("Rev" + thisRow.score_type, new_value);
     691      }
     692    }
     693    // Now put this into the info string
     694    Set<String> score_names = score_types.keySet();
     695    Iterator<String> it = score_names.iterator();
     696    if (getCutOff()!=null)
     697    {
     698      if (peptideFilter)
     699      {
     700        info+="Filtering by peptide and protein score. ";
     701      }
     702      else
     703      {
     704        info+="Filtering by protein score only. ";
     705      }
     706      info +="E-value cutoff:"+getCutOff().toString();
     707    }
     708    if (getScoreTypeFilter()!=null)
     709    {
     710      info+=" Filtered by score types starting with:"+getScoreTypeFilter();
     711    }
     712    while (it.hasNext())
     713    {
     714      String s = it.next();
     715      if (!s.startsWith("Rev"))
     716      {
     717        int rev = score_types.get("Rev" + s).intValue();
     718        int tot = score_types.get(s).intValue();
     719        info += "Of score type " + s + " there where " + rev + " reverse hits out of " + tot + " total hits.";
     720      }
     721    }
     722    return new TreeSet(result);
     723  }
     724
     725
    602726  public void setDate(String date)
    603727  {
    604728    this.date = date;
    605729  }
     730
     731
    606732  public String getDate()
    607733  {
    608734    return date;
    609735  }
     736
     737
    610738  public void setReverseText(String reverseText)
    611739  {
    612740    this.reverseText = reverseText;
    613741  }
     742
     743
    614744  public String getReverseText()
    615745  {
    616746    return reverseText;
    617747  }
    618  
     748
     749
    619750  public void setCutOff(Double cutOff)
    620751  {
    621752    this.cutOff = cutOff.floatValue();
    622753  }
     754
     755
    623756  public Double getCutOff()
    624757  {
    625758    return new Double(cutOff);
    626759  }
    627  
     760
     761
    628762  public void setCutOffAbove(Boolean cutOffAbove)
    629763  {
    630764    this.cutOffAbove = cutOffAbove.booleanValue();
    631765  }
     766
     767
    632768  public Boolean isCutOffAbove()
    633769  {
    634770    return new Boolean(cutOffAbove);
    635771  }
    636 /* 
    637   public void setHitsPerGelItem(Integer hitsPerGelItem)
    638   {
    639     this.hitsPerGelItem = hitsPerGelItem.intValue();
    640   }
    641   public Integer getHitsPerGelItem()
    642   {
    643     return new Integer(hitsPerGelItem);
    644   }
    645 */
    646   public void setDescending(Boolean descending)
    647   {
    648     this.descending = descending.booleanValue();
    649   }
    650   public Boolean getDescending()
    651   {
    652     return new Boolean(descending);
    653   }
    654  
     772
     773
     774  public void setPeptideFilter(Boolean peptide)
     775  {
     776    this.peptideFilter = peptide.booleanValue();
     777  }
     778
     779
     780  public Boolean getPeptideFilter()
     781  {
     782    return new Boolean(peptideFilter);
     783  }
     784
     785
     786  public void setScoreTypeFilter(String filter)
     787  {
     788    this.scoreFilter = filter;
     789  }
     790
     791
     792  public String getScoreTypeFilter()
     793  {
     794    return scoreFilter;
     795  }
     796
    655797  /**
    656     This abstract inner class stores data for one row in the report. It also
    657     contains a compareTo method that will sort the objects correct as specified
    658     by the parameter to the constructor.
    659   */
     798   * This abstract inner class stores data for one row in the report. It also
     799   * contains a compareTo method that will sort the objects correct as
     800   * specified by the parameter to the constructor.
     801   */
    660802  public class ResultRow
    661     implements Comparable
    662   {
    663     ResultRow(boolean descending)
    664     {
    665       this.descending = descending;
    666     }
    667    
     803      implements Comparable
     804  {
     805    ResultRow()
     806    {
     807      ;
     808    }
     809
     810
    668811    /**
    669       Comparator that for sorting the objects according to dBSearchId, SpotId,
    670       and eValue. Sorting by evalue will be ascending or descending depending
    671       on the value of the descending variable
    672      
    673       @param o The object to compare with.
    674     */
     812     * Comparator that for sorting the objects according to dBSearchId,
     813     * SpotId, and eValue. Sorting will be ascending.
     814     *
     815     * @param o The object to compare with.
     816     */
    675817    public int compareTo(Object o)
    676818    {
    677       int compValue = 1;
    678       ResultRow other = (ResultRow)o;
    679       if ((this.dBSearchId.compareTo(other.dBSearchId)) == 0)
    680       {
    681         if (this.spotId <= other.spotId)
    682         {
    683           if (this.score_type.equals(other.score_type))
    684           {
    685             if (this.eValue <= other.eValue)
    686             {
    687               if (!descending)
    688               {
    689                 compValue = -1;
    690               }
    691             }
    692             else
    693             {
    694               if (descending)
    695               {
    696                 compValue = 1;
    697               }
    698             }
    699           }
    700           else
    701           {
    702             compValue = -(this.score_type.compareTo(other.score_type));
    703           }         
    704         }
    705       }
    706       return compValue;
    707     }
    708    
     819      /*
     820       * int compValue = 1; ResultRow other = (ResultRow) o; if
     821       * ((this.dBSearchId.compareTo(other.dBSearchId)) == 0) { if
     822       * (this.spotId <= other.spotId) { if
     823       * (this.score_type.equals(other.score_type)) { if (this.eValue <=
     824       * other.eValue) { compValue = -1; } } else { compValue =
     825       * -(this.score_type .compareTo(other.score_type)); } } } return
     826       * compValue;
     827       */
     828      return 1;
     829    }
     830
     831
    709832    public String toString()
    710833    {
    711       String out = dfXML.format(dBSearchId)+"\t"+spotId+"\t"+eValue+"\t"+score+"\t"+score_type+"\t"+proteinId+"\t"+description+"\t"+coverage+"\t"+mw+"\t"+pi+"\t"+MPTargetId+"\t"
    712         +MPTargetPosition+"\t"+MPId+"\t"+MPLabel+"\t"+matchedPeaks+"\t"+totalPeaks+"\t"+rms+"\t"+totalIntensity+"\t"+exp_mr+"\t"+exp_z+"\t"+delta;
     834      String out = dfXML.format(dBSearchId) + "\t" + spotId + "\t" + eValue + "\t" + score + "\t" + score_type + "\t" + proteinId + "\t" + description + "\t" + coverage + "\t" + mw + "\t" + pi + "\t" + MPTargetId + "\t" + MPTargetPosition + "\t" + MPId + "\t" + MPLabel + "\t" + matchedPeaks + "\t" + totalPeaks + "\t" + rms + "\t" + totalIntensity + "\t" + exp_mr + "\t" + exp_z + "\t" + delta;
    713835      return out;
    714836    }
    715    
    716     // Tells if this object should be sorted descending.
    717     private boolean descending;
    718    
     837
    719838    // Variables to be included in the report.
    720839    public Date dBSearchId;
     
    725844    public String MPTargetPosition;
    726845    public double eValue;
    727     public String proteinId="";
     846    public String proteinId = "";
    728847    public String description;
    729848    public String score_type;
     
    737856    public double exp_mr;
    738857    public int exp_z;
    739     public int matchedPeaks=0;
     858    public int matchedPeaks = 0;
    740859    public int totalPeaks;
    741860  }
     
    744863  DateFormat dfDate = DateFormat.getDateInstance();
    745864  SimpleDateFormat dfXML = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss");
    746  
    747865  private SQLEvictConnection dbconnection;
    748866  private Set resultSet;
    749867  private String gelId;
    750868  private String date;
    751   private String info="";
    752   private String reverseText="";
     869  private String info = "";
     870  private String reverseText = "";
     871  private String scoreFilter;
    753872  private double cutOff;
    754873  private boolean cutOffAbove;
    755 //  private int hitsPerGelItem = 0;
    756   private boolean descending=false;
     874  // private int hitsPerGelItem = 0;
     875  private boolean peptideFilter = false;
    757876}
Note: See TracChangeset for help on using the changeset viewer.