peptiderawfragmentmasses.cpp

Go to the documentation of this file.

/**
 * \file pappsomspp/peptide/peptiderawfragmentmasses.cpp
 * \date 16/7/2016
 * \author Olivier Langella
 * \brief class dedicated to raw mass computations of peptide products
 * (fragments)
 */
 
/*******************************************************************************
 * Copyright (c) 2016 Olivier Langella <Olivier.Langella@moulon.inra.fr>.
 *
 * This file is part of the PAPPSOms++ library.
 *
 *     PAPPSOms++ is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     PAPPSOms++ is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with PAPPSOms++.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Contributors:
 *     Olivier Langella <Olivier.Langella@moulon.inra.fr> - initial API and
 *implementation
 ******************************************************************************/
 
#include "peptiderawfragmentmasses.h"
namespace pappso
{
 
 
PeptideRawFragmentMasses::ionDeltatMzMassMap
  PeptideRawFragmentMasses::m_ionDeltaMz = {
    [(std::int8_t)Enums::PeptideIon::b]     = 0,
    [(std::int8_t)Enums::PeptideIon::bstar] = -MASSNH3,
    [(std::int8_t)Enums::PeptideIon::bo]    = -MASSH2O,
    [(std::int8_t)Enums::PeptideIon::a]     = -MASSCO,
    [(std::int8_t)Enums::PeptideIon::astar] = -MASSCO - MASSNH3,
    [(std::int8_t)Enums::PeptideIon::ao]    = -MASSCO - MASSH2O,
    [(std::int8_t)Enums::PeptideIon::bp]    = -1,
    [(std::int8_t)Enums::PeptideIon::c]     = MASSNH3,
    [(std::int8_t)Enums::PeptideIon::y]     = MASSH2O,
    [(std::int8_t)Enums::PeptideIon::ystar] = MASSH2O - MASSNH3,
    [(std::int8_t)Enums::PeptideIon::yo]    = 0,
    [(std::int8_t)Enums::PeptideIon::z]     = MASSOXYGEN - MASSNITROGEN - MPROTIUM,
    [(std::int8_t)Enums::PeptideIon::yp]    = -1,
    [(std::int8_t)Enums::PeptideIon::x]     = MASSCO + MASSOXYGEN};
 
 
pappso_double
PeptideRawFragmentMasses::getDeltaMass(Enums::PeptideIon ion_type)
{
  return m_ionDeltaMz[(std::int8_t)ion_type];
}
 
 
PeptideRawFragmentMasses::PeptideRawFragmentMasses(const Peptide &peptide,
                                                   RawFragmentationMode mode)
{
 
  qDebug() ;
  std::vector<Aa>::const_iterator it(peptide.begin());
  std::vector<Aa>::const_iterator end(peptide.end());
  if(it == end)
    return;
 
  qDebug() ;
  pappso_double cumulative_mass = it->getMass();
  if (peptide.getNterModification() != nullptr) {
    cumulative_mass += peptide.getNterModification()->getMass();
  }
  qDebug() ;
  m_cumulativeNterMasses.push_back(cumulative_mass);
  it++;
 
  if(it != end)
    {
      end--;
      qDebug() ;
      while(it != end)
        {
 
          qDebug() 
                   << " cumulative_mass=" << cumulative_mass;
          cumulative_mass += it->getMass();
          if((mode == RawFragmentationMode::proline_effect) &&
             (it->getLetter() == 'P'))
            {
            }
          else
            {
              m_cumulativeNterMasses.push_back(cumulative_mass);
            }
          it++;
        }
    }
 
  qDebug() ;
  std::vector<Aa>::const_reverse_iterator rit(peptide.rbegin());
  std::vector<Aa>::const_reverse_iterator ritf(peptide.rbegin());
  std::vector<Aa>::const_reverse_iterator rend(peptide.rend());
  ritf++;
  cumulative_mass = rit->getMass();
  if (peptide.getCterModification() != nullptr) {
    cumulative_mass += peptide.getCterModification()->getMass();
  }
  if((mode == RawFragmentationMode::proline_effect) && (ritf != rend) &&
     (ritf->getLetter() == 'P'))
    {
    }
  else
    {
      m_cumulativeCterMasses.push_back(cumulative_mass);
    }
  qDebug() ;
 
  rit++;
  ritf++;
  if(rit != rend)
    {
      rend--;
      while(rit != rend)
        {
          cumulative_mass += rit->getMass();
          if((mode == RawFragmentationMode::proline_effect) &&
             (ritf != peptide.rend()) && (ritf->getLetter() == 'P'))
            {
            }
          else
            {
              m_cumulativeCterMasses.push_back(cumulative_mass);
            }
          rit++;
          ritf++;
        }
    }
 
  qDebug() ;
}
 
void
PeptideRawFragmentMasses::pushBackIonMasses(
  std::vector<pappso_double> &mass_list, Enums::PeptideIon ion_type) const
{
  const std::vector<pappso_double> *p_mass_list = &m_cumulativeCterMasses;
 
  if(peptideIonIsNter(ion_type))
    {
      // nter
      p_mass_list = &m_cumulativeNterMasses;
    }
 
  for(pappso_double mass : *p_mass_list)
    {
      mass_list.push_back(mass + m_ionDeltaMz[(std::int8_t)ion_type]);
    }
}
 
void
PeptideRawFragmentMasses::pushBackIonMz(std::vector<pappso_double> &mass_list,
                                        Enums::PeptideIon ion_type,
                                        unsigned int charge) const
{
  const std::vector<pappso_double> *p_mass_list = &m_cumulativeCterMasses;
 
  if(peptideIonIsNter(ion_type))
    {
      // nter
      p_mass_list = &m_cumulativeNterMasses;
    }
 
  for(pappso_double mass : *p_mass_list)
    {
      mass_list.push_back(
        (mass + m_ionDeltaMz[(std::int8_t)ion_type] + (MHPLUS * charge)) /
        charge);
    }
}
 
void
PeptideRawFragmentMasses::pushBackMatchSpectrum(
  std::vector<SimplePeakIonMatch> &peak_match_list,
  const MassSpectrum &spectrum,
  PrecisionPtr precision,
  Enums::PeptideIon ion_type,
  unsigned int charge) const
{
  std::vector<pappso_double> mass_list;
  pushBackIonMz(mass_list, ion_type, charge);
 
  // no need to sort
  // std::sort(mass_list.begin(), mass_list.end());
 
  std::vector<pappso_double>::iterator it_mz     = mass_list.begin();
  std::vector<pappso_double>::iterator it_mz_end = mass_list.end();
 
  // scan products over each peak in spectrum :
  std::vector<DataPoint>::const_iterator it_peak     = spectrum.begin();
  std::vector<DataPoint>::const_iterator it_peak_end = spectrum.end();
  unsigned int ion_size                              = 1;
  while((it_peak != it_peak_end) && (it_mz != it_mz_end))
    {
      MzRange massrange(it_peak->x, precision);
      if((*it_mz) > massrange.upper())
        {
          it_peak++;
          continue;
        }
      if((*it_mz) < massrange.lower())
        {
          it_mz++;
          ion_size++;
          continue;
        }
      peak_match_list.push_back(
        {(*it_peak), ion_type, ion_size, charge, (*it_mz)});
      it_mz++;
      ion_size++;
    }
}
 
PeptideRawFragmentMasses::~PeptideRawFragmentMasses()
{
}
} // namespace pappso