work on PTM islands

src/core/peptidematch.cpp

@@ -45,15 +45,15 @@ void PeptideMatch::setRetentionTime(pappso::pappso_double rt) {
 void PeptideMatch::setEvalue(pappso::pappso_double evalue) {
     _evalue = evalue;
 }
-        
-    /** \brief set specific parameter value
-     */
+
+/** \brief set specific parameter value
+ */
 void PeptideMatch::setParam(PeptideMatchParam param, const QVariant& value) {
     _params.insert(std::pair<PeptideMatchParam, QVariant>(param, value));
 }
 const QVariant PeptideMatch::getParam(PeptideMatchParam param) const {
     try {
-    return _params.at(param);
+        return _params.at(param);
     }
     catch (std::out_of_range) {
         return QVariant();
@@ -74,12 +74,12 @@ pappso::pappso_double PeptideMatch::getExperimentalMass() const {
     return _exp_mass;
 }
 pappso::pappso_double PeptideMatch::getExperimentalMz() const {
-  pappso::mz mz = _exp_mass;
-  for (unsigned int i=0; i < _charge; i++) {
-    mz+=pappso::MHPLUS;
-  }
-  mz = mz/_charge;
-  return mz;
+    pappso::mz mz = _exp_mass;
+    for (unsigned int i=0; i < _charge; i++) {
+        mz+=pappso::MHPLUS;
+    }
+    mz = mz/_charge;
+    return mz;
 }
 void PeptideMatch::setExperimentalMass(pappso::pappso_double exp_mass) {
     _exp_mass =exp_mass;
@@ -96,6 +96,17 @@ unsigned int PeptideMatch::getStart() const {
 unsigned int PeptideMatch::getStop() const {
     return _start+_peptide_sp.get()->size();
 }
+
+void PeptideMatch::containsPosition(unsigned int position) {
+    if (position < _start) {
+        return false;
+    }
+    if (position < getStop()) {
+        return true;
+    }
+    return false;
+
+}
 void PeptideMatch::setCharge(unsigned int charge) {
     _charge =charge;
 }

src/core/peptidematch.h

@@ -109,6 +109,11 @@ public :
     pappso::mz getDeltaMass() const;
 
     ValidationState getValidationState() const;
+    
+    /** @brief tells if this peptide contains a position
+     * the position is the amino acid position on the protein sequence (starts from 0)
+     * */
+    void containsPosition(unsigned int position);
 
 private :
     static std::hash<std::string> _hash_fn;

src/grouping/ptm/ptmgroupingexperiment.cpp

@@ -72,15 +72,49 @@ PtmGroupingExperiment::~PtmGroupingExperiment()
 
 }
 
+void PtmGroupingExperiment::addProteinMatch(const ProteinMatch* p_protein_match) {
+    if (p_protein_match->getValidationState() >= _peptide_validation_state) {
+        std::vector< unsigned int > ptm_position_list = getPtmPositions(p_protein_match);
+        std::vector<PtmIslandSp> ptm_island_list;
+        for (unsigned int position : ptm_position_list) {
+            ptm_island_list.push_back(std::make_shared<PtmIsland>(p_protein_match, position));
+        }
+        for (PeptideMatch * p_peptide_match: p_protein_match->getPeptideMatchList(_peptide_validation_state)) {
+            for (PtmIslandSp ptm_island_sp:ptm_island_list) {
+                ptm_island_sp.get()->addPeptideMatch(p_peptide_match);
+            }
+        }
+
+        std::vector< PtmIslandSp > protein_ptm_islands = mergePeptideMatchPtmIslandList(ptm_island_list);
+	//=> ptm island subgroups (same set of sample scan numbers)
+    }
+}
+
+std::vector< PtmIslandSp > PtmGroupingExperiment::mergePeptideMatchPtmIslandList(std::vector< PtmIslandSp > ptm_island_list) {
+    std::vector< PtmIslandSp > new_ptm_island_list;
+
+    for (PtmIslandSp ptm_island_sp:ptm_island_list) {
+        //http://en.cppreference.com/w/cpp/algorithm/all_any_none_of
+        if (std::none_of(new_ptm_island_list.begin(), new_ptm_island_list.end(), [ptm_island_sp](PtmIslandSp element) {
+        return element.get()->merge(ptm_island_sp);
+        })) {
+            new_ptm_island_list.push_back(ptm_island_sp);
+        }
+    }
+    
+    return new_ptm_island_list;
+
+}
+
 std::vector<unsigned int> PtmGroupingExperiment::getPtmPositions(const ProteinMatch * protein_match) const {
     std::vector<unsigned int> position_list;
 
     for (PeptideMatch * p_peptide_match: protein_match->getPeptideMatchList(_peptide_validation_state)) {
         unsigned int start = p_peptide_match->getStart();
         for (pappso::AaModificationP modification: _modification_list) {
-          for (unsigned int position : p_peptide_match->getPeptideXtpSp().get()->getModificationPositionList(modification)) {
-              position_list.push_back(start+position);
-          }
+            for (unsigned int position : p_peptide_match->getPeptideXtpSp().get()->getModificationPositionList(modification)) {
+                position_list.push_back(start+position);
+            }
         }
     }
     std::sort(position_list.begin(), position_list.end());

src/grouping/ptm/ptmgroupingexperiment.h

@@ -32,14 +32,20 @@
 
 #include "../../core/proteinmatch.h"
 #include <pappsomspp/amino_acid/aamodification.h>
+#include "ptmisland.h"
 
 class PtmGroupingExperiment
 {
 public:
     PtmGroupingExperiment(const PtmGroupingExperiment& other);
     ~PtmGroupingExperiment();
+    
+    void addProteinMatch(const ProteinMatch* p_protein_match);
 
+private:
     std::vector<unsigned int> getPtmPositions(const ProteinMatch * protein_match) const;
+    
+    std::vector< PtmIslandSp > mergePeptideMatchPtmIslandList(vector< PtmIslandSp > ptm_island_list);
 private:
     std::list<pappso::AaModificationP> _modification_list;
     ValidationState _peptide_validation_state = ValidationState::validAndChecked;

src/grouping/ptm/ptmisland.cpp

@@ -28,13 +28,66 @@
 ******************************************************************************/
 
 #include "ptmisland.h"
+#include <pappsomspp/pappsoexception.h>
 
-PtmIsland::PtmIsland()
+PtmIsland::PtmIsland(const ProteinMatch* p_protein_match, unsigned int position)
 {
-
+    _position_list.push_back(position);
+    _protein_match_p = p_protein_match;
 }
 
 PtmIsland::~PtmIsland()
 {
 
 }
+bool PtmIsland::containsPeptideMatch(const PeptideMatch* peptide_match) const {
+
+    return std::any_of(_peptide_match_list.begin(), _peptide_match_list.end(), [peptide_match](const PeptideMatch* element) {
+        return ( peptide_match == element);
+    });
+}
+
+void PtmIsland::addPeptideMatch(const PeptideMatch* p_peptide_match) {
+    if (_position_list.size()==1) {
+        unsigned int position = _position_list[0];
+        if (p_peptide_match->containsPosition(position)) {
+            _peptide_match_list.push_back(p_peptide_match);
+        }
+    }
+    else {
+        throw pappso::PappsoException(QObject::tr("not able to add peptide match if _position_list.size()!=1 (%1)").arg(_position_list.size()));
+    }
+}
+
+bool PtmIsland::merge(PtmIslandSp ptm_island_sp) {
+    if (std::none_of(_peptide_match_list.begin(), _peptide_match_list.end(), [ptm_island_sp](const PeptideMatch* element) {
+    return ptm_island_sp.get()->containsPeptideMatch(element);
+    })) {
+        return false;
+    }
+    else {
+        //so we merge
+        _peptide_match_list.insert(0,ptm_island_sp.get()->_peptide_match_list.begin(),ptm_island_sp.get()->_peptide_match_list.end());
+        std::sort(_peptide_match_list.begin(), _peptide_match_list.end());
+        auto last = std::unique(_peptide_match_list.begin(), _peptide_match_list.end());
+        _peptide_match_list.erase(last, _peptide_match_list.end());
+	
+	_position_list.insert(0,ptm_island_sp.get()->_position_list.begin(),ptm_island_sp.get()->_position_list.end());
+        std::sort(_position_list.begin(), _position_list.end());
+        _position_list.erase(std::unique(_position_list.begin(), _position_list.end()), _position_list.end());
+
+
+        PeptideMatch  * result = std::max_element(_peptide_match_list.begin(), _peptide_match_list.end(), [](const PeptideMatch * a, const PeptideMatch * b)
+        {
+            return  a->getStop() < b->getStop();
+        });
+        _protein_stop = result->getStop();
+
+        result = std::min_element(_peptide_match_list.begin(), _peptide_match_list.end(), [](const PeptideMatch * a, const PeptideMatch * b)
+        {
+            return  a->getStart() < b->getStart();
+        });
+        _protein_start = result->getStart();
+        return true;
+    }
+}

src/grouping/ptm/ptmisland.h

@@ -32,18 +32,37 @@
 
 #include "../../core/proteinmatch.h"
 #include "../../core/peptidematch.h"
+#include <memory>
+
+PtmIslandSp
+
+class PtmIsland;
+
+/** \brief shared pointer on a Peptide object
+ */
+typedef std::shared_ptr<PtmIsland> PtmIslandSp;
 
 class PtmIsland
 {
 public:
-    PtmIsland();
+    PtmIsland(const ProteinMatch* p_protein_match, unsigned int position);
     ~PtmIsland();
+    void addPeptideMatch(const PeptideMatch* p_peptide_match);
+    
+    /** @brief merge with the given ptm island if there is at least one common peptide match
+     * */
+    bool merge(PtmIslandSp ptm_island_sp);
+    
+    bool containsPeptideMatch(const PeptideMatch* element) const;
 private:
     ProteinMatch * _protein_match_p;
     std::vector<PeptideMatch *> _peptide_match_list;
-    std::vector<std::size_t> _sample_scan_set;
+    //std::vector<std::size_t> _sample_scan_set;
     unsigned int _group_number; //group together different ptmislands linked by a common protein
     unsigned int _subgroup_number; //group together proteins that share the same ptmisland
+    std::vector<unsigned int> _position_list;
+    unsigned int _protein_stop=0;
+    unsigned int _protein_start=0;
 };
 
 #endif // PTMISLAND_H