pappso::specpeptidoms::SpOMSSpectrum Class Reference

#include <spomsspectrum.h>

Inheritance diagram for pappso::specpeptidoms::SpOMSSpectrum:

Public Member Functions
	SpOMSSpectrum (pappso::QualifiedMassSpectrum &qmass_spectrum, pappso::PrecisionPtr precision_ptr, const pappso::AaCode &aaCode)
	SpOMSSpectrum (const SpOMSSpectrumCsp &other)
	SpOMSSpectrum (const SpOMSSpectrumCsp &other, double precursor_mass_error)
	Returns a copy of the provided spectrum accounting for the provided precursor mass error. More...
virtual	~SpOMSSpectrum ()
void	addAaPosition (uint8_t aa, const std::size_t r_peak, const std::size_t l_peak, const std::size_t next_l_peak, bool l_support)
	Adds an amino acid position to the data structure. More...
std::vector< AaPosition > &	getAaPositions (const Aa &aa) const
	Returns the list of aa_positions for a given amino acid. More...
std::vector< AaPosition >	getAaPositions (const Aa &aa, std::vector< std::size_t > peaks_to_remove) const
	Returns the list of aa_positions for a given amino acid, except those relying on provided peaks. More...
std::vector< double >	getMassList () const
	Returns the spectrum's list of masses. More...
specglob::ExperimentalSpectrumDataPointType	peakType (std::size_t indice) const
	Returns the type of one of the spectrum's peaks. More...
uint	getPrecursorCharge () const
	Returns the spectrum's precursor's charge. More...
double	getMissingMass (std::size_t peak) const
	Returns the missing mass between a peak and the precursor's mass (shift at the end). More...
double	getMZShift (std::size_t l_peak, std::size_t r_peak) const
	Returns the mz difference between two peaks. More...
std::size_t	getComplementaryPeak (std::size_t peak) const

Private Member Functions
void	preprocessSpectrum ()
	Preprocess the spectrum. More...
void	removeUnsupportedMasses ()
	Removes the unsupported peaks (without an amino acid to the left) from the spectrum. More...
uint32_t	computeCondition (const std::size_t l_peak, bool l_support) const
	Computes the "condition" integer, used to apply the three peaks rule. More...
void	addSupportedPeak (std::size_t peak)
	Add a peak to the supported peaks list. More...
void	correctPeakIndexes ()
	Reindexes the peaks after removal of the unsupported peaks. More...
void	fillComplementaryPeakIndexes ()
	For each point of the spectrum, indicate the index of its complementary peak;. More...

Private Attributes
pappso::QualifiedMassSpectrum	m_qualifiedMassSpectrum
std::vector< std::shared_ptr< std::vector< AaPosition > > >	m_aapositions
pappso::PrecisionPtr	m_precision_ptr
std::vector< std::shared_ptr< std::vector< uint8_t > > >	m_supported_peaks
std::vector< int >	m_reindexed_peaks
const pappso::AaCode &	m_aaCode
std::vector< std::size_t >	m_complementary_peak_indexes
double	m_precursor_mass_error

Detailed Description

Definition at line 67 of file spomsspectrum.h.

Constructor & Destructor Documentation

SpOMSSpectrum() [1/3]

pappso::specpeptidoms::SpOMSSpectrum::SpOMSSpectrum	(	pappso::QualifiedMassSpectrum &	qmass_spectrum,
		pappso::PrecisionPtr	precision_ptr,
		const pappso::AaCode &	aaCode
	)

Default constructor

Parameters

exp_spectrum	ExperimentalSpectrum to preprocess
precision_ptr	Precision to use for preprocessing

Definition at line 40 of file spomsspectrum.cpp.

  : std::vector<pappso::specglob::ExperimentalSpectrumDataPoint>(
      specglob::ExperimentalSpectrum(qmass_spectrum, precision_ptr)),
    m_aaCode(aaCode),
    m_qualifiedMassSpectrum(qmass_spectrum),
    m_precision_ptr(precision_ptr),
    m_precursor_mass_error(0)
{
  m_aapositions.reserve(m_aaCode.getSize());
  for(std::size_t iter = 0; iter < m_aaCode.getSize(); iter++)
    {
      m_aapositions.push_back(std::make_shared<std::vector<AaPosition>>());
      m_aapositions.back()->reserve(this->size() - 1);
    }
  m_supported_peaks.reserve(this->size());
  m_supported_peaks.push_back(std::make_shared<std::vector<uint8_t>>());
  m_reindexed_peaks.push_back(0);
  for(std::size_t iter = 1; iter < this->size(); iter++)
    {
      m_supported_peaks.push_back(std::make_shared<std::vector<uint8_t>>());
      m_reindexed_peaks.push_back(-1);
    }
  this->at(0).peak_mz  = pappso::MHPLUS + 2 * pappso::MPROTIUM + pappso::MASSOXYGEN;
  this->back().peak_mz = m_qualifiedMassSpectrum.getPrecursorMass() + pappso::MHPLUS;
  preprocessSpectrum();
}

References pappso::QualifiedMassSpectrum::getPrecursorMass(), pappso::AaCode::getSize(), m_aaCode, m_aapositions, m_qualifiedMassSpectrum, m_reindexed_peaks, m_supported_peaks, pappso::MASSOXYGEN(), pappso::MHPLUS(), pappso::MPROTIUM(), and preprocessSpectrum().

SpOMSSpectrum() [2/3]

pappso::specpeptidoms::SpOMSSpectrum::SpOMSSpectrum

(

const SpOMSSpectrumCsp &

other

)

Copy constructor

Parameters

other

SpOMSSpectrum to copy

Definition at line 69 of file spomsspectrum.cpp.

  : std::vector<pappso::specglob::ExperimentalSpectrumDataPoint>(
      pappso::specglob::ExperimentalSpectrum(other->m_qualifiedMassSpectrum,
                                             other->m_precision_ptr)),
    m_qualifiedMassSpectrum(other->m_qualifiedMassSpectrum),
    m_aapositions(other->m_aapositions),
    m_precision_ptr(other->m_precision_ptr),
    m_supported_peaks(other->m_supported_peaks),
    m_reindexed_peaks(other->m_reindexed_peaks),
    m_aaCode(other->m_aaCode),
    m_complementary_peak_indexes(other->m_complementary_peak_indexes),
    m_precursor_mass_error(other->m_precursor_mass_error)
{
}

SpOMSSpectrum() [3/3]

pappso::specpeptidoms::SpOMSSpectrum::SpOMSSpectrum	(	const SpOMSSpectrumCsp &	other,
		double	precursor_mass_error
	)

Returns a copy of the provided spectrum accounting for the provided precursor mass error.

Post-processing constructor

Parameters

other	SpOMSSpectrum to copy
precursor_mass_error	precursor mass error to account for

Definition at line 84 of file spomsspectrum.cpp.

  : std::vector<pappso::specglob::ExperimentalSpectrumDataPoint>(
      pappso::specglob::ExperimentalSpectrum(
        other->m_qualifiedMassSpectrum, other->m_precision_ptr, precursor_mass_error)),
    m_qualifiedMassSpectrum(other->m_qualifiedMassSpectrum),
    m_precision_ptr(other->m_precision_ptr),
    m_aaCode(other->m_aaCode),
    m_precursor_mass_error(precursor_mass_error)
{
  m_aapositions.reserve(m_aaCode.getSize());
  for(std::size_t iter = 0; iter < m_aaCode.getSize(); iter++)
    {
      m_aapositions.push_back(std::make_shared<std::vector<AaPosition>>());
      m_aapositions.back()->reserve(this->size() - 1);
    }
  m_supported_peaks.reserve(this->size());
  m_supported_peaks.push_back(std::make_shared<std::vector<uint8_t>>());
  m_reindexed_peaks.push_back(0);
  for(std::size_t iter = 1; iter < this->size(); iter++)
    {
      m_supported_peaks.push_back(std::make_shared<std::vector<uint8_t>>());
      m_reindexed_peaks.push_back(-1);
    }
  this->at(0).peak_mz = pappso::MHPLUS + 2 * pappso::MPROTIUM + pappso::MASSOXYGEN;
  this->back().peak_mz =
    m_qualifiedMassSpectrum.getPrecursorMass() + pappso::MHPLUS + precursor_mass_error;
  preprocessSpectrum();
}

References pappso::QualifiedMassSpectrum::getPrecursorMass(), pappso::AaCode::getSize(), m_aaCode, m_aapositions, m_qualifiedMassSpectrum, m_reindexed_peaks, m_supported_peaks, pappso::MASSOXYGEN(), pappso::MHPLUS(), pappso::MPROTIUM(), and preprocessSpectrum().

~SpOMSSpectrum()

pappso::specpeptidoms::SpOMSSpectrum::~SpOMSSpectrum ( )

virtual

Destructor

Definition at line 114 of file spomsspectrum.cpp.

{
}

Member Function Documentation

addAaPosition()

void pappso::specpeptidoms::SpOMSSpectrum::addAaPosition	(	uint8_t	aa,
		const std::size_t	r_peak,
		const std::size_t	l_peak,
		const std::size_t	next_l_peak,
		bool	l_support
	)

Adds an amino acid position to the data structure.

Parameters

aa	Amino acid to add to the data structure
r_peak	index of the amino acid's right support peak
l_peak	index of the amino acid's left support peak, if it is supported by an amino acid, otherwise see next_l_peak
next_l_peak	index of the first supported peak to the left of the amino acid's left support peak
l_support	indicates whether the amino acid's left support peak if supported by an amino acid

Definition at line 233 of file spomsspectrum.cpp.

{
  // aa=0 corresponds to no amino acid identified, thus aa is always >=1. We substract 1 to aa to
  // avoid keeping an empty, useless vector.
  if(l_support)
    {
      m_aapositions.at(aa - 1)->push_back(
        {r_peak, l_peak, next_l_peak, computeCondition(l_peak, l_support), l_support});
    }
  else
    {
      m_aapositions.at(aa - 1)->push_back(
        {r_peak, next_l_peak, next_l_peak, computeCondition(l_peak, l_support), l_support});
    }
}

addSupportedPeak()

void pappso::specpeptidoms::SpOMSSpectrum::addSupportedPeak ( std::size_t  peak )

private

Add a peak to the supported peaks list.

Definition at line 338 of file spomsspectrum.cpp.

{
  std::size_t counter = 0;
  for(std::size_t iter = 0; iter < peak; iter++)
    {
      if(m_reindexed_peaks.at(iter) >= 0)
        {
          counter++;
        }
    }
  m_reindexed_peaks.at(peak) = counter;
  for(std::size_t iter = peak + 1; iter < m_reindexed_peaks.size(); iter++)
    {
      if(m_reindexed_peaks.at(iter) >= 0)
        {
          m_reindexed_peaks.at(iter)++;
        }
    }
}

computeCondition()

uint32_t pappso::specpeptidoms::SpOMSSpectrum::computeCondition ( const std::size_t  l_peak, bool  l_support  ) const

private

Computes the "condition" integer, used to apply the three peaks rule.

Definition at line 254 of file spomsspectrum.cpp.

{
  uint32_t condition;
  if(l_peak == 0)
    {
      condition = 2;
    }
  else if(!l_support)
    {
      condition = 1;
    }
  else
    {
      condition = 0;
      for(std::vector<uint8_t>::iterator aa = m_supported_peaks.at(l_peak)->begin();
          aa != m_supported_peaks.at(l_peak)->end();
          aa++)
        {
          condition += 2 << *(aa);
        }
    }
  return condition;
}

correctPeakIndexes()

void pappso::specpeptidoms::SpOMSSpectrum::correctPeakIndexes ( )

private

Reindexes the peaks after removal of the unsupported peaks.

Definition at line 359 of file spomsspectrum.cpp.

{
  for(auto aa = m_aapositions.begin(); aa != m_aapositions.end(); aa++)
    {
      for(auto aap = aa->get()->begin(); aap != aa->get()->end(); aap++)
        {
          aap->l_peak      = m_reindexed_peaks.at(aap->l_peak);
          aap->r_peak      = m_reindexed_peaks.at(aap->r_peak);
          aap->next_l_peak = m_reindexed_peaks.at(aap->next_l_peak);
        }
    }
}

fillComplementaryPeakIndexes()

void pappso::specpeptidoms::SpOMSSpectrum::fillComplementaryPeakIndexes ( )

private

For each point of the spectrum, indicate the index of its complementary peak;.

Definition at line 373 of file spomsspectrum.cpp.

{
  std::size_t left_index, right_index;
 
  m_complementary_peak_indexes.reserve(this->size());
  while(m_complementary_peak_indexes.size() < this->size())
    {
      m_complementary_peak_indexes.push_back(0);
    }
  left_index       = 0;
  right_index      = this->size() - 1;
  double comp_mass = m_qualifiedMassSpectrum.getPrecursorMass() + 2 * MHPLUS;
 
  while(left_index < right_index)
    {
      pappso::MzRange mz_range(comp_mass - this->at(left_index).peak_mz, m_precision_ptr);
      if(mz_range.contains(this->at(right_index).peak_mz))
        {
          m_complementary_peak_indexes.at(left_index)  = right_index;
          m_complementary_peak_indexes.at(right_index) = left_index;
          qDebug() << left_index << right_index;
        }
      if(comp_mass - this->at(left_index).peak_mz - this->at(right_index).peak_mz >= 0)
        {
          left_index++;
        }
      else
        {
          right_index--;
        }
    }
}

References pappso::MzRange::contains(), and pappso::MHPLUS().

getAaPositions() [1/2]

std::vector< pappso::specpeptidoms::AaPosition > & pappso::specpeptidoms::SpOMSSpectrum::getAaPositions

(

const Aa &

aa

)

const

Returns the list of aa_positions for a given amino acid.

Parameters

aa	Amino acid for which to retrieve positions

Definition at line 280 of file spomsspectrum.cpp.

{
  return *m_aapositions.at(m_aaCode.getAaCode(aa.getLetter()) - 1);
}

getAaPositions() [2/2]

std::vector< pappso::specpeptidoms::AaPosition > pappso::specpeptidoms::SpOMSSpectrum::getAaPositions	(	const Aa &	aa,
		std::vector< std::size_t >	peaks_to_remove
	)		const

Returns the list of aa_positions for a given amino acid, except those relying on provided peaks.

Definition at line 286 of file spomsspectrum.cpp.

{
  std::vector<AaPosition> aa_positions;
  for(auto aap : *m_aapositions.at(m_aaCode.getAaCode(aa.getLetter()) - 1))
    {
      if(std::find(peaks_to_remove.begin(), peaks_to_remove.end(), aap.r_peak) ==
         peaks_to_remove.end())
        {
          aa_positions.push_back(aap);
        }
    }
  return aa_positions;
}

getComplementaryPeak()

std::size_t pappso::specpeptidoms::SpOMSSpectrum::getComplementaryPeak

(

std::size_t

peak

)

const

Definition at line 407 of file spomsspectrum.cpp.

{
  return m_complementary_peak_indexes.at(peak);
}

getMassList()

std::vector< double > pappso::specpeptidoms::SpOMSSpectrum::getMassList

(

)

const

Returns the spectrum's list of masses.

Definition at line 302 of file spomsspectrum.cpp.

{
  std::vector<double> mass_list;
  for(const specglob::ExperimentalSpectrumDataPoint &n : *this)
    {
      mass_list.push_back(n.peak_mz);
    }
  return mass_list;
}

References pappso::specglob::ExperimentalSpectrumDataPoint::peak_mz.

getMissingMass()

double pappso::specpeptidoms::SpOMSSpectrum::getMissingMass

(

std::size_t

peak

)

const

Returns the missing mass between a peak and the precursor's mass (shift at the end).

Definition at line 331 of file spomsspectrum.cpp.

{
  return this->m_qualifiedMassSpectrum.getPrecursorMass() - m_precursor_mass_error -
         this->at(peak).peak_mz + MHPLUS;
}

References pappso::MHPLUS().

getMZShift()

double pappso::specpeptidoms::SpOMSSpectrum::getMZShift	(	std::size_t	l_peak,
		std::size_t	r_peak
	)		const

Returns the mz difference between two peaks.

Parameters

l_peak	left peak
r_peak	right peak

Definition at line 325 of file spomsspectrum.cpp.

{
  return this->at(r_peak).peak_mz - this->at(l_peak).peak_mz;
}

getPrecursorCharge()

uint pappso::specpeptidoms::SpOMSSpectrum::getPrecursorCharge

(

)

const

Returns the spectrum's precursor's charge.

Definition at line 319 of file spomsspectrum.cpp.

{
  return m_qualifiedMassSpectrum.getPrecursorCharge();
}

peakType()

pappso::specglob::ExperimentalSpectrumDataPointType pappso::specpeptidoms::SpOMSSpectrum::peakType

(

std::size_t

indice

)

const

Returns the type of one of the spectrum's peaks.

Parameters

indice

Peak index to be identified

Definition at line 313 of file spomsspectrum.cpp.

{
  return this->at(indice).type;
}

preprocessSpectrum()

void pappso::specpeptidoms::SpOMSSpectrum::preprocessSpectrum ( )

private

Preprocess the spectrum.

Definition at line 120 of file spomsspectrum.cpp.

{
  bool found;
  uint8_t aa;
  std::vector<double>::iterator iter1, iter2;
  std::size_t peak1, peak2, next_l_peak;
  std::vector<double> mass_list = getMassList();
 
  peak1 = -1;
  for(iter1 = mass_list.begin(); iter1 != mass_list.end(); iter1++)
    {
      peak1++;
      peak2 = peak1;
      for(iter2 = iter1 + 1; iter2 != mass_list.end(); iter2++)
        {
          peak2++;
          aa = m_aaCode.getAaCodeByMass(*(iter2) - *(iter1), m_precision_ptr);
          if(aa != 0)
            {
              next_l_peak = 0;
              for(std::size_t iter = 1; iter < peak1;
                  iter++) // Search of the closer supported left peak.
                // Possible optimization => search from the right
                {
                  if(m_reindexed_peaks.at(iter) >= 0)
                    {
                      next_l_peak = iter;
                    }
                }
              if(m_reindexed_peaks.at(peak2) == -1)
                {
                  addSupportedPeak(peak2);
                  m_supported_peaks.at(peak2)->push_back(aa);
                }
              if(m_reindexed_peaks.at(peak1) >= 0)
                {
                  addAaPosition(aa, peak2, peak1, next_l_peak, true);
                }
              else
                {
                  addAaPosition(aa, peak2, next_l_peak, next_l_peak, false);
                }
            }
        }
    }
 
  removeUnsupportedMasses();
  correctPeakIndexes();
 
  // std::size_t i = 0;
  // for(auto &data_point : *this)
  //   {
  //     data_point.indice = i;
  //     i++;
  //   }
 
  fillComplementaryPeakIndexes();
}

References pappso::specpeptidoms::found.

Referenced by SpOMSSpectrum().

removeUnsupportedMasses()

void pappso::specpeptidoms::SpOMSSpectrum::removeUnsupportedMasses ( )

private

Removes the unsupported peaks (without an amino acid to the left) from the spectrum.

Definition at line 216 of file spomsspectrum.cpp.

{
  std::vector<specglob::ExperimentalSpectrumDataPoint> kept_peaks;
  for(std::vector<specglob::ExperimentalSpectrumDataPoint>::iterator iter = this->begin();
      iter != this->end();
      iter++)
    {
      if(m_reindexed_peaks.at(iter->indice) >= 0)
        {
          kept_peaks.push_back(*iter);
        }
    }
  this->clear();
  this->assign(kept_peaks.begin(), kept_peaks.end());
}

Member Data Documentation

m_aaCode

const pappso::AaCode& pappso::specpeptidoms::SpOMSSpectrum::m_aaCode

private

Definition at line 165 of file spomsspectrum.h.

Referenced by SpOMSSpectrum().

m_aapositions

std::vector<std::shared_ptr<std::vector<AaPosition> > > pappso::specpeptidoms::SpOMSSpectrum::m_aapositions

private

Definition at line 160 of file spomsspectrum.h.

Referenced by SpOMSSpectrum().

m_complementary_peak_indexes

std::vector<std::size_t> pappso::specpeptidoms::SpOMSSpectrum::m_complementary_peak_indexes

private

Definition at line 166 of file spomsspectrum.h.

m_precision_ptr

pappso::PrecisionPtr pappso::specpeptidoms::SpOMSSpectrum::m_precision_ptr

private

Definition at line 161 of file spomsspectrum.h.

m_precursor_mass_error

double pappso::specpeptidoms::SpOMSSpectrum::m_precursor_mass_error

private

Definition at line 167 of file spomsspectrum.h.

m_qualifiedMassSpectrum

pappso::QualifiedMassSpectrum pappso::specpeptidoms::SpOMSSpectrum::m_qualifiedMassSpectrum

private

Definition at line 159 of file spomsspectrum.h.

Referenced by SpOMSSpectrum().

m_reindexed_peaks

std::vector<int> pappso::specpeptidoms::SpOMSSpectrum::m_reindexed_peaks

private

Definition at line 163 of file spomsspectrum.h.

Referenced by SpOMSSpectrum().

m_supported_peaks

std::vector<std::shared_ptr<std::vector<uint8_t> > > pappso::specpeptidoms::SpOMSSpectrum::m_supported_peaks

private

Definition at line 162 of file spomsspectrum.h.

Referenced by SpOMSSpectrum().

---

The documentation for this class was generated from the following files:

• pappsomspp/processing/specpeptidoms/spomsspectrum.h
• pappsomspp/processing/specpeptidoms/spomsspectrum.cpp