q-value can be computed on Mascot results

src/core/identification_sources/identificationdatasource.cpp

@@ -130,6 +130,27 @@ IdentificationDataSource::getIdentificationEngineName() const
       case IdentificationEngine::peptider:
         name = "peptider";
         break;
+      case IdentificationEngine::mascot:
+        name = "Mascot";
+        break;
+
+      case IdentificationEngine::OMSSA:
+        name = "OMSSA";
+        break;
+      case IdentificationEngine::SEQUEST:
+        name = "SEQUEST";
+        break;
+      case IdentificationEngine::Comet:
+        name = "Comet";
+        break;
+      case IdentificationEngine::Morpheus:
+        name = "Morpheus";
+        break;
+      case IdentificationEngine::MSGFplus:
+        name = "MS-GF+";
+        break;
+      default:
+        break;
     }
   return name;
 }

src/core/qvalue/computeqvalues.cpp

@@ -40,19 +40,13 @@ ComputeQvalues::ComputeQvalues(ProjectSp project_sp)
 
 
   std::vector<PeptideEvidence *> tandem_peptide_evidence_list;
+  std::vector<PeptideEvidence *> mascot_peptide_evidence_list;
   for(auto &identification_source_sp : identification_source_list)
     {
-      if(identification_source_sp.get()->getIdentificationEngine() !=
+      if(identification_source_sp.get()->getIdentificationEngine() ==
          IdentificationEngine::XTandem)
         {
-          throw pappso::ExceptionNotImplemented(
-            QObject::tr("q-value computation for %1 identification engine is "
-                        "not yet implemented")
-              .arg(
-                identification_source_sp.get()->getIdentificationEngineName()));
-        }
-      else
-        {
+
           tandem_peptide_evidence_list.reserve(
             tandem_peptide_evidence_list.size() +
             identification_source_sp.get()->getPeptideEvidenceStore().size());
@@ -63,6 +57,28 @@ ComputeQvalues::ComputeQvalues(ProjectSp project_sp)
               tandem_peptide_evidence_list.push_back(pe_sp.get());
             }
         }
+      else if(identification_source_sp.get()->getIdentificationEngine() ==
+              IdentificationEngine::mascot)
+        {
+          mascot_peptide_evidence_list.reserve(
+            mascot_peptide_evidence_list.size() +
+            identification_source_sp.get()->getPeptideEvidenceStore().size());
+          for(auto &pe_sp : identification_source_sp.get()
+                              ->getPeptideEvidenceStore()
+                              .getPeptideEvidenceList())
+            {
+              mascot_peptide_evidence_list.push_back(pe_sp.get());
+            }
+        }
+      else
+        {
+
+          throw pappso::ExceptionNotImplemented(
+            QObject::tr("q-value computation for %1 identification engine is "
+                        "not yet implemented")
+              .arg(
+                identification_source_sp.get()->getIdentificationEngineName()));
+        }
     }
 
   for(auto &identification_group :
@@ -78,12 +94,54 @@ ComputeQvalues::ComputeQvalues(ProjectSp project_sp)
         }
     }
   computeTandemPeptideEvidenceQvalues(tandem_peptide_evidence_list);
+
+  computeMascotPeptideEvidenceQvalues(mascot_peptide_evidence_list);
 }
 
 ComputeQvalues::~ComputeQvalues()
 {
 }
 
+void
+ComputeQvalues::computeMascotPeptideEvidenceQvalues(
+  std::vector<PeptideEvidence *> &mascot_peptide_evidence_list) const
+{
+
+  // mascot_expectation_value
+  std::sort(mascot_peptide_evidence_list.begin(),
+            mascot_peptide_evidence_list.end(),
+            [](const PeptideEvidence *pepa, const PeptideEvidence *pepb) {
+              QVariant evalue_a =
+                pepa->getParam(PeptideEvidenceParam::mascot_expectation_value);
+              QVariant evalue_b =
+                pepb->getParam(PeptideEvidenceParam::mascot_expectation_value);
+              if(evalue_a.isNull() || evalue_b.isNull())
+                {
+                  throw pappso::ExceptionNotImplemented(QObject::tr(
+                    "Mascot Evalue is missing, unable to compute q-value"));
+                }
+              return (evalue_a.toDouble() < evalue_b.toDouble());
+            });
+  std::size_t count_decoy  = 0;
+  std::size_t count_target = 0;
+  for(PeptideEvidence *pep : mascot_peptide_evidence_list)
+    {
+      if(m_falsePeptideEvidenceList.find(pep) !=
+         m_falsePeptideEvidenceList.end())
+        {
+          count_decoy++;
+        }
+      else
+        {
+          count_target++;
+        }
+      double qvalue = Utils::computeFdr(count_decoy, count_target);
+      pep->setParam(PeptideEvidenceParam::pappso_qvalue, QVariant(qvalue));
+    }
+
+  cleanPeptideEvidenceList(mascot_peptide_evidence_list);
+}
+
 void
 ComputeQvalues::computeTandemPeptideEvidenceQvalues(
   std::vector<PeptideEvidence *> &tandem_peptide_evidence_list) const
@@ -110,12 +168,19 @@ ComputeQvalues::computeTandemPeptideEvidenceQvalues(
       pep->setParam(PeptideEvidenceParam::pappso_qvalue, QVariant(qvalue));
     }
 
+  cleanPeptideEvidenceList(tandem_peptide_evidence_list);
+}
+
+void
+ComputeQvalues::cleanPeptideEvidenceList(
+  std::vector<PeptideEvidence *> &peptide_evidence_list) const
+{
   qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
   // check reverse list to clean q-values
-  auto rit = tandem_peptide_evidence_list.rbegin();
+  auto rit = peptide_evidence_list.rbegin();
 
   double qvalue_max = 99999999;
-  while(rit != tandem_peptide_evidence_list.rend())
+  while(rit != peptide_evidence_list.rend())
     {
       if((*rit)->getParam(PeptideEvidenceParam::pappso_qvalue).toDouble() >
          qvalue_max)

src/core/qvalue/computeqvalues.h

@@ -49,6 +49,11 @@ class ComputeQvalues
   private:
   void computeTandemPeptideEvidenceQvalues(
     std::vector<PeptideEvidence *> &tandem_peptide_evidence_list) const;
+  void computeMascotPeptideEvidenceQvalues(
+    std::vector<PeptideEvidence *> &mascot_peptide_evidence_list) const;
+
+  void cleanPeptideEvidenceList(
+    std::vector<PeptideEvidence *> &peptide_evidence_list) const;
 
   private:
   std::set<const PeptideEvidence *> m_falsePeptideEvidenceList;