pappso::MsRunRetentionTime< T > Class Template Reference

#include <msrunretentiontime.h>

Classes
struct	PeptideMs2Point

Public Member Functions
	MsRunRetentionTime (MsRunReaderSPtr msrun_reader_sp)
	MsRunRetentionTime (const MsRunRetentionTime< T > &other)
	~MsRunRetentionTime ()
pappso::MsRunReaderSPtr	getMsRunReaderSPtr () const
void	setMs2MedianFilter (const FilterMorphoMedian &ms2MedianFilter)
void	setMs2MeanFilter (const FilterMorphoMean &ms2MeanFilter)
void	setMs1MeanFilter (const FilterMorphoMean &ms1MeanFilter)
Trace	getCommonDeltaRt (const std::vector< MsRunRetentionTimeSeamarkPoint< T >> &other_seamarks) const
void	addPeptideAsSeamark (const T &peptide_str, std::size_t ms2_spectrum_index)
	collects all peptide evidences of a given MSrun seamarks has to be converted to peptide retention time using computePeptideRetentionTimes More...
void	computePeptideRetentionTimes ()
	convert Peptide seamarks into PeptideMs2Point this is required before computing alignment More...
std::size_t	getNumberOfCorrectedValues () const
Trace	align (const MsRunRetentionTime< T > &msrun_retention_time_reference)
const std::vector< MsRunRetentionTimeSeamarkPoint< T > > &	getSeamarks () const
const std::vector< double > &	getAlignedRetentionTimeVector () const
const std::vector< RtPoint > &	getMs1RetentionTimeVector () const
bool	isAligned () const
double	translateOriginal2AlignedRetentionTime (double original_retention_time) const

Protected Member Functions
double	getFrontRetentionTimeReference () const
double	getBackRetentionTimeReference () const
const std::vector< MsRunRetentionTimeSeamarkPoint< T > >	getSeamarksReferences () const

Private Types
enum	ComputeRetentionTimeReference { ComputeRetentionTimeReference::maximum_intensity, ComputeRetentionTimeReference::weighted_intensity, ComputeRetentionTimeReference::last }

Private Member Functions
void	getCommonDeltaRt (Trace &delta_rt, const std::vector< MsRunRetentionTimeSeamarkPoint< T >> &other_seamarks) const
void	correctNewTimeValues (Trace &ms1_aligned_points, double correction_parameter)
void	linearRegressionMs2toMs1 (Trace &ms1_aligned_points, const Trace &common_points)

Private Attributes
FilterMorphoMedian	m_ms2MedianFilter
FilterMorphoMean	m_ms2MeanFilter
FilterMorphoMean	m_ms1MeanFilter
pappso::MsRunReaderSPtr	msp_msrunReader
pappso::MsRunIdCstSPtr	mcsp_msrunId
std::vector< RtPoint >	m_ms1RetentionTimeVector
std::vector< double >	m_alignedRetentionTimeVector
std::vector< MsRunRetentionTimeSeamarkPoint< T > >	m_seamarks
std::size_t	m_valuesCorrected = 0
std::vector< PeptideMs2Point >	m_allMs2Points
ComputeRetentionTimeReference	m_retentionTimeReferenceMethod

Detailed Description

template<class T>
class pappso::MsRunRetentionTime< T >

Definition at line 49 of file msrunretentiontime.h.

Member Enumeration Documentation

ComputeRetentionTimeReference

template<class T >

enum pappso::MsRunRetentionTime::ComputeRetentionTimeReference

strongprivate

Enumerator
maximum_intensity
weighted_intensity
last

Definition at line 59 of file msrunretentiontime.h.

  {
    maximum_intensity,
    weighted_intensity,
    last
  };

Constructor & Destructor Documentation

MsRunRetentionTime() [1/2]

template<class T >

MsRunRetentionTime::MsRunRetentionTime

(

MsRunReaderSPtr

msrun_reader_sp

)

Definition at line 82 of file msrunretentiontime.cpp.

  : m_ms2MedianFilter(10), m_ms2MeanFilter(15), m_ms1MeanFilter(1)
{
  msp_msrunReader = msrun_reader_sp;
  mcsp_msrunId    = msp_msrunReader.get()->getMsRunId();
  RetentionTimeReader handler(m_ms1RetentionTimeVector);
  msrun_reader_sp.get()->readSpectrumCollection(handler);
 
 
  std::sort(m_ms1RetentionTimeVector.begin(),
            m_ms1RetentionTimeVector.end(),
            [](const RtPoint &a, const RtPoint &b) {
              return (a.retentionTime < b.retentionTime);
            });
}

References pappso::MsRunRetentionTime< T >::m_ms1RetentionTimeVector, pappso::MsRunRetentionTime< T >::mcsp_msrunId, and pappso::MsRunRetentionTime< T >::msp_msrunReader.

MsRunRetentionTime() [2/2]

template<class T >

MsRunRetentionTime::MsRunRetentionTime

(

const MsRunRetentionTime< T > &

other

)

Definition at line 99 of file msrunretentiontime.cpp.

  : m_ms2MedianFilter(other.m_ms2MedianFilter),
    m_ms2MeanFilter(other.m_ms2MeanFilter),
    m_ms1MeanFilter(other.m_ms1MeanFilter)
{
  msp_msrunReader              = other.msp_msrunReader;
  mcsp_msrunId                 = other.mcsp_msrunId;
  m_ms1RetentionTimeVector     = other.m_ms1RetentionTimeVector;
  m_alignedRetentionTimeVector = other.m_alignedRetentionTimeVector;
 
  m_seamarks        = other.m_seamarks;
  m_valuesCorrected = other.m_valuesCorrected;
 
  m_allMs2Points = other.m_allMs2Points;
 
  m_retentionTimeReferenceMethod = other.m_retentionTimeReferenceMethod;
}

References pappso::MsRunRetentionTime< T >::m_alignedRetentionTimeVector, pappso::MsRunRetentionTime< T >::m_allMs2Points, pappso::MsRunRetentionTime< T >::m_ms1RetentionTimeVector, pappso::MsRunRetentionTime< T >::m_retentionTimeReferenceMethod, pappso::MsRunRetentionTime< T >::m_seamarks, pappso::MsRunRetentionTime< T >::m_valuesCorrected, pappso::MsRunRetentionTime< T >::mcsp_msrunId, and pappso::MsRunRetentionTime< T >::msp_msrunReader.

~MsRunRetentionTime()

template<class T >

MsRunRetentionTime::~MsRunRetentionTime

Definition at line 118 of file msrunretentiontime.cpp.

{
}

Member Function Documentation

addPeptideAsSeamark()

template<class T >

void MsRunRetentionTime::addPeptideAsSeamark	(	const T &	peptide_str,
		std::size_t	ms2_spectrum_index
	)

collects all peptide evidences of a given MSrun seamarks has to be converted to peptide retention time using computePeptideRetentionTimes

Definition at line 184 of file msrunretentiontime.cpp.

{
 
  qDebug();
  msp_msrunReader.get()->acquireDevice();
  PeptideMs2Point ms2point;
  ms2point.entityHash = peptide_id;
  QualifiedMassSpectrum spectrum =
    msp_msrunReader.get()->qualifiedMassSpectrum(ms2_spectrum_index, false);
  ms2point.precursorIntensity = spectrum.getPrecursorIntensity();
  ms2point.retentionTime      = spectrum.getRtInSeconds();
 
  // addSeamark(m_hash_fn(peptide_str.toStdString()), retentionTime);
 
  m_allMs2Points.push_back(ms2point);
 
  qDebug();
}

References pappso::MsRunRetentionTime< T >::PeptideMs2Point::entityHash, pappso::QualifiedMassSpectrum::getPrecursorIntensity(), pappso::QualifiedMassSpectrum::getRtInSeconds(), pappso::MsRunRetentionTime< T >::PeptideMs2Point::precursorIntensity, and pappso::MsRunRetentionTime< T >::PeptideMs2Point::retentionTime.

align()

template<class T >

Trace MsRunRetentionTime::align

(

const MsRunRetentionTime< T > &

msrun_retention_time_reference

)

Definition at line 411 of file msrunretentiontime.cpp.

{
  std::vector<MsRunRetentionTimeSeamarkPoint<T>> other_seamarks;
  if(msrun_retention_time_reference.isAligned())
    {
      other_seamarks = msrun_retention_time_reference.getSeamarksReferences();
    }
  else
    {
      other_seamarks = msrun_retention_time_reference.getSeamarks();
    }
  qDebug();
  if((m_ms1MeanFilter.getHalfWindowSize() * 2 + 1) >=
     m_ms1RetentionTimeVector.size())
    {
      throw ExceptionNotPossible(
        QObject::tr("ERROR : MS1 alignment of MS run '%1' (%2)' not possible : "
                    "\ntoo few MS1 points (%3)")
          .arg(msp_msrunReader.get()->getMsRunId().get()->getXmlId())
          .arg(msp_msrunReader.get()->getMsRunId().get()->getFileName())
          .arg(m_ms1RetentionTimeVector.size()));
    }
 
  qDebug() << m_seamarks[0].entityHash << " " << m_seamarks[0].retentionTime
           << " " << other_seamarks[0].entityHash
           << other_seamarks[0].retentionTime << " ";
  // both seamarks has to be ordered
  Trace common_points;
  getCommonDeltaRt(common_points, other_seamarks);
 
  // writeTrace("lib_ms2_delta_rt.ods", common_points);
 
  qDebug() << common_points.front().x << " " << common_points.front().y;
  m_ms2MedianFilter.filter(common_points);
  // writeTrace("lib_ms2_delta_rt_median.ods", common_points);
  m_ms2MeanFilter.filter(common_points);
  // writeTrace("lib_ms2_delta_rt_mean.ods", common_points);
  // convert common delta rt to real retention times (for convenience)
  qDebug() << common_points.front().x << " " << common_points.front().y;
 
 
  // add a first point to ensure coherence:
  DataPoint first_point;
  first_point.x = m_ms1RetentionTimeVector.front().retentionTime - (double)1;
  if(first_point.x < 0)
    {
      first_point.x = 0;
    }
  first_point.y =
    m_ms1RetentionTimeVector.front().retentionTime -
    msrun_retention_time_reference.getFrontRetentionTimeReference();
 
  common_points.push_back(first_point);
  // add a last point to ensure coherence:
  DataPoint last_point;
  last_point.x = m_ms1RetentionTimeVector.back().retentionTime + 1;
  last_point.y = m_ms1RetentionTimeVector.back().retentionTime -
                 msrun_retention_time_reference.getBackRetentionTimeReference();
  common_points.push_back(last_point);
  common_points.sortX();
 
  // now, it is possible for each time range to give a new MS1 time using a
  // linear regression on MS2 corrected times
  m_alignedRetentionTimeVector.clear();
 
  qDebug() << common_points.front().x << " " << common_points.front().y;
 
  Trace ms1_aligned_points;
 
  linearRegressionMs2toMs1(ms1_aligned_points, common_points);
 
  // writeTrace("lib_ms1_map_rt.ods", ms1_aligned_points);
  qDebug();
  // smoothing on MS1 points
  m_ms1MeanFilter.filter(ms1_aligned_points);
 
  // writeTrace("lib_ms1_map_rt_mean.ods", ms1_aligned_points);
  // final aligned retentionTime vector
 
  for(DataPoint &data_point : ms1_aligned_points)
    {
      data_point.y = (data_point.x - data_point.y);
    }
 
  qDebug();
  // Here, the correction parameter is the slope of old rt points curve
  // (divided by 4 to get a finer correction).
  double correction_parameter =
    (m_ms1RetentionTimeVector.back().retentionTime -
     m_ms1RetentionTimeVector.front().retentionTime) /
    (ms1_aligned_points.size());
  // set_correction_parameter(correction_parameter / 4);
  correction_parameter = correction_parameter / (double)4;
  correctNewTimeValues(ms1_aligned_points, correction_parameter);
 
  m_alignedRetentionTimeVector = ms1_aligned_points.yValues();
 
  qDebug();
  return ms1_aligned_points;
}

References pappso::Trace::filter(), pappso::MsRunRetentionTime< T >::getBackRetentionTimeReference(), pappso::MsRunRetentionTime< T >::getFrontRetentionTimeReference(), pappso::MsRunRetentionTime< T >::getSeamarks(), pappso::MsRunRetentionTime< T >::getSeamarksReferences(), pappso::MsRunRetentionTime< T >::isAligned(), pappso::Trace::sortX(), pappso::DataPoint::x, and pappso::DataPoint::y.

computePeptideRetentionTimes()

template<class T >

void MsRunRetentionTime::computePeptideRetentionTimes

convert Peptide seamarks into PeptideMs2Point this is required before computing alignment

Definition at line 206 of file msrunretentiontime.cpp.

{
 
  qDebug();
  if(msp_msrunReader == nullptr)
    {
      throw ExceptionNotPossible(
        QObject::tr("ERROR : msp_msrunReader == nullptr"));
    }
  m_seamarks.clear();
  if(m_retentionTimeReferenceMethod ==
     ComputeRetentionTimeReference::maximum_intensity)
    {
 
 
      std::sort(m_allMs2Points.begin(),
                m_allMs2Points.end(),
                [](const PeptideMs2Point &a, const PeptideMs2Point &b) {
                  if(a.entityHash == b.entityHash)
                    {
                      return (a.precursorIntensity > b.precursorIntensity);
                    }
                  return (a.entityHash < b.entityHash);
                });
 
      auto itend =
        std::unique(m_allMs2Points.begin(),
                    m_allMs2Points.end(),
                    [](const PeptideMs2Point &a, const PeptideMs2Point &b) {
                      return (a.entityHash == b.entityHash);
                    });
 
      auto it = m_allMs2Points.begin();
      while(it != itend)
        {
          m_seamarks.push_back(
            {it->entityHash, it->retentionTime, it->precursorIntensity});
          it++;
        }
    }
  msp_msrunReader = nullptr;
  m_allMs2Points.clear();
 
  std::sort(m_seamarks.begin(),
            m_seamarks.end(),
            [](const MsRunRetentionTimeSeamarkPoint<T> &a,
               const MsRunRetentionTimeSeamarkPoint<T> &b) {
              return (a.entityHash < b.entityHash);
            });
  qDebug();
}

References pappso::MsRunRetentionTime< T >::PeptideMs2Point::entityHash.

correctNewTimeValues()

template<class T >

void MsRunRetentionTime::correctNewTimeValues ( Trace &  ms1_aligned_points, double  correction_parameter  )

private

Definition at line 569 of file msrunretentiontime.cpp.

{
 
  m_valuesCorrected = 0;
  auto new_it(ms1_aligned_points.begin());
  auto new_nextit(ms1_aligned_points.begin());
  new_nextit++;
  for(; new_nextit != ms1_aligned_points.end(); ++new_nextit, ++new_it)
    {
      if(new_nextit->y < new_it->y)
        {
          ++m_valuesCorrected;
          new_nextit->y = new_it->y + correction_parameter;
        }
    }
}

getAlignedRetentionTimeVector()

template<class T >

const std::vector< double > & MsRunRetentionTime::getAlignedRetentionTimeVector

Definition at line 154 of file msrunretentiontime.cpp.

{
  return m_alignedRetentionTimeVector;
}

getBackRetentionTimeReference()

template<class T >

double MsRunRetentionTime::getBackRetentionTimeReference

protected

Definition at line 327 of file msrunretentiontime.cpp.

{
  if(isAligned())
    {
      return m_alignedRetentionTimeVector.back();
    }
  return m_ms1RetentionTimeVector.back().retentionTime;
}

Referenced by pappso::MsRunRetentionTime< T >::align().

getCommonDeltaRt() [1/2]

template<class T >

Trace MsRunRetentionTime::getCommonDeltaRt

(

const std::vector< MsRunRetentionTimeSeamarkPoint< T >> &

other_seamarks

)

const

Definition at line 174 of file msrunretentiontime.cpp.

{
  Trace common_points;
  getCommonDeltaRt(common_points, other_seamarks);
  return common_points;
}

getCommonDeltaRt() [2/2]

template<class T >

void MsRunRetentionTime::getCommonDeltaRt ( Trace &  delta_rt, const std::vector< MsRunRetentionTimeSeamarkPoint< T >> &  other_seamarks  ) const

private

Definition at line 260 of file msrunretentiontime.cpp.

{
 
  qDebug();
  auto it = other_seamarks.begin();
 
  for(const MsRunRetentionTimeSeamarkPoint<T> &seamark : m_seamarks)
    {
      while((it != other_seamarks.end()) &&
            (it->entityHash < seamark.entityHash))
        {
          it++;
        }
      if(it == other_seamarks.end())
        break;
      if(it->entityHash == seamark.entityHash)
        {
          delta_rt.push_back(DataPoint(
            seamark.retentionTime, seamark.retentionTime - it->retentionTime));
        }
    }
 
  qDebug();
  if((m_ms2MedianFilter.getHalfWindowSize() * 2 + 1) >= delta_rt.size())
    {
      throw ExceptionNotPossible(
        QObject::tr("ERROR : MS2 alignment of MS run '%1' (%2)' not possible : "
                    "\ntoo few MS2 points (%3) in common")
          .arg(msp_msrunReader.get()->getMsRunId().get()->getXmlId())
          .arg(msp_msrunReader.get()->getMsRunId().get()->getFileName())
          .arg(delta_rt.size()));
    }
 
  qDebug();
  if((m_ms2MeanFilter.getHalfWindowSize() * 2 + 1) >= delta_rt.size())
    {
      throw ExceptionNotPossible(
        QObject::tr("ERROR : MS2 alignment of MS run '%1' (%2)' not possible : "
                    "\ntoo few MS2 points (%3) in common")
          .arg(msp_msrunReader.get()->getMsRunId().get()->getXmlId())
          .arg(msp_msrunReader.get()->getMsRunId().get()->getFileName())
          .arg(delta_rt.size()));
    }
  delta_rt.sortX();
 
  // there can be multiple entities (peptides) at one retention time
  // in this case, avoid retention time redundancy by applying unique on trace :
  delta_rt.unique();
 
  qDebug();
}

References pappso::Trace::sortX(), and pappso::Trace::unique().

getFrontRetentionTimeReference()

template<class T >

double MsRunRetentionTime::getFrontRetentionTimeReference

protected

Definition at line 317 of file msrunretentiontime.cpp.

{
  if(isAligned())
    {
      return m_alignedRetentionTimeVector.front();
    }
  return m_ms1RetentionTimeVector.front().retentionTime;
}

Referenced by pappso::MsRunRetentionTime< T >::align().

getMs1RetentionTimeVector()

template<class T >

const std::vector< RtPoint > & MsRunRetentionTime::getMs1RetentionTimeVector

Definition at line 167 of file msrunretentiontime.cpp.

{
  return m_ms1RetentionTimeVector;
}

getMsRunReaderSPtr()

template<typename T >

pappso::MsRunReaderSPtr pappso::MsRunRetentionTime< T >::getMsRunReaderSPtr

Definition at line 590 of file msrunretentiontime.cpp.

{
  return msp_msrunReader;
}

getNumberOfCorrectedValues()

template<class T >

std::size_t MsRunRetentionTime::getNumberOfCorrectedValues

Definition at line 161 of file msrunretentiontime.cpp.

{
  return m_valuesCorrected;
}

getSeamarks()

template<class T >

const std::vector< MsRunRetentionTimeSeamarkPoint< T > > & MsRunRetentionTime::getSeamarks

Definition at line 146 of file msrunretentiontime.cpp.

{
  qDebug();
  return m_seamarks;
}

Referenced by pappso::MsRunRetentionTime< T >::align().

getSeamarksReferences()

template<class T >

const std::vector< MsRunRetentionTimeSeamarkPoint< T > > MsRunRetentionTime::getSeamarksReferences

protected

Definition at line 391 of file msrunretentiontime.cpp.

{
  std::vector<MsRunRetentionTimeSeamarkPoint<T>> other_seamarks = m_seamarks;
  for(auto &seamark : other_seamarks)
    {
      seamark.retentionTime =
        translateOriginal2AlignedRetentionTime(seamark.retentionTime);
    }
  return other_seamarks;
}

Referenced by pappso::MsRunRetentionTime< T >::align().

isAligned()

template<class T >

bool MsRunRetentionTime::isAligned

Definition at line 404 of file msrunretentiontime.cpp.

{
  return (m_alignedRetentionTimeVector.size() > 0);
}

Referenced by pappso::MsRunRetentionTime< T >::align().

linearRegressionMs2toMs1()

template<class T >

void MsRunRetentionTime::linearRegressionMs2toMs1 ( Trace &  ms1_aligned_points, const Trace &  common_points  )

private

Definition at line 516 of file msrunretentiontime.cpp.

{
 
  // first slope :
  std::vector<DataPoint>::const_iterator itms2     = common_points.begin();
  std::vector<DataPoint>::const_iterator itms2next = itms2 + 1;
  if(itms2next == common_points.end())
    {
      // error
      throw ExceptionNotPossible(
        QObject::tr("ERROR : MS1 alignment of MS run '%1' (%2)' not possible : "
                    "\ntoo few common points (%3)")
          .arg(msp_msrunReader.get()->getMsRunId().get()->getXmlId())
          .arg(msp_msrunReader.get()->getMsRunId().get()->getFileName())
          .arg(common_points.size()));
    }
  qDebug() << "() itms2->x=" << itms2->x << " itms2->y=" << itms2->y;
 
  for(RtPoint &original_rt_point : m_ms1RetentionTimeVector)
    {
      DataPoint ms1_point;
      ms1_point.x = original_rt_point.retentionTime;
 
      while(ms1_point.x > itms2next->x)
        {
          itms2++;
          itms2next++;
        }
 
      double ratio = (itms2next->x - itms2->x);
      if(ratio != 0)
        {
          ratio = (ms1_point.x - itms2->x) / ratio;
        }
      else
        {
          // avoid division by zero
          ratio = 1;
        }
      // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "() " <<
      // ratio;
 
      ms1_point.y = itms2->y + ((itms2next->y - itms2->y) * ratio);
 
      // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "() "
      //         << ms1_point.y;
      ms1_aligned_points.push_back(ms1_point);
    }
}

References pappso::DataPoint::x, and pappso::DataPoint::y.

setMs1MeanFilter()

template<class T >

void MsRunRetentionTime::setMs1MeanFilter

(

const FilterMorphoMean &

ms1MeanFilter

)

Definition at line 139 of file msrunretentiontime.cpp.

{
  m_ms1MeanFilter = ms1MeanFilter;
}

setMs2MeanFilter()

template<class T >

void MsRunRetentionTime::setMs2MeanFilter

(

const FilterMorphoMean &

ms2MeanFilter

)

Definition at line 132 of file msrunretentiontime.cpp.

{
  m_ms2MeanFilter = ms2MeanFilter;
}

setMs2MedianFilter()

template<class T >

void MsRunRetentionTime::setMs2MedianFilter

(

const FilterMorphoMedian &

ms2MedianFilter

)

Definition at line 124 of file msrunretentiontime.cpp.

{
  m_ms2MedianFilter = ms2MedianFilter;
}

translateOriginal2AlignedRetentionTime()

template<class T >

double MsRunRetentionTime::translateOriginal2AlignedRetentionTime

(

double

original_retention_time

)

const

Definition at line 339 of file msrunretentiontime.cpp.

{
  if(m_alignedRetentionTimeVector.size() < 3)
    {
      throw ExceptionNotPossible(
        QObject::tr("ERROR : too few aligned points to compute aligned "
                    "retention time (%1)")
          .arg(m_ms1RetentionTimeVector.size()));
    }
  if(m_alignedRetentionTimeVector.size() != m_ms1RetentionTimeVector.size())
    {
      throw ExceptionNotPossible(
        QObject::tr("ERROR : m_alignedRetentionTimeVector.size() %1 != %2 "
                    "m_ms1RetentionTimeVector.size()")
          .arg(m_alignedRetentionTimeVector.size())
          .arg(m_ms1RetentionTimeVector.size()));
    }
  auto it_plus =
    std::find_if(m_ms1RetentionTimeVector.begin(),
                 m_ms1RetentionTimeVector.end(),
                 [original_retention_time](const RtPoint &rt_point) {
                   return original_retention_time < rt_point.retentionTime;
                 });
  double rt1_a, rt2_a, rt1_b, rt2_b;
  if(it_plus == m_ms1RetentionTimeVector.end())
    {
      it_plus--;
    }
  if(it_plus == m_ms1RetentionTimeVector.begin())
    {
      it_plus++;
    }
  auto it_minus = it_plus - 1;
 
  rt1_a = it_minus->retentionTime;
  rt2_a = it_plus->retentionTime;
 
  double ratio = (original_retention_time - rt1_a) / (rt2_a - rt1_a);
 
  auto itref = m_alignedRetentionTimeVector.begin() +
               std::distance(m_ms1RetentionTimeVector.begin(), it_minus);
 
  rt1_b = *itref;
  itref++;
  rt2_b = *itref;
 
  return (((rt2_b - rt1_b) * ratio) + rt1_b);
}

Member Data Documentation

m_alignedRetentionTimeVector

template<class T >

std::vector<double> pappso::MsRunRetentionTime< T >::m_alignedRetentionTimeVector

private

Definition at line 128 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

m_allMs2Points

template<class T >

std::vector<PeptideMs2Point> pappso::MsRunRetentionTime< T >::m_allMs2Points

private

Definition at line 133 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

m_ms1MeanFilter

template<class T >

FilterMorphoMean pappso::MsRunRetentionTime< T >::m_ms1MeanFilter

private

Definition at line 124 of file msrunretentiontime.h.

m_ms1RetentionTimeVector

template<class T >

std::vector<RtPoint> pappso::MsRunRetentionTime< T >::m_ms1RetentionTimeVector

private

Definition at line 127 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

m_ms2MeanFilter

template<class T >

FilterMorphoMean pappso::MsRunRetentionTime< T >::m_ms2MeanFilter

private

Definition at line 123 of file msrunretentiontime.h.

m_ms2MedianFilter

template<class T >

FilterMorphoMedian pappso::MsRunRetentionTime< T >::m_ms2MedianFilter

private

Definition at line 122 of file msrunretentiontime.h.

m_retentionTimeReferenceMethod

template<class T >

ComputeRetentionTimeReference pappso::MsRunRetentionTime< T >::m_retentionTimeReferenceMethod

private

Initial value:

=
    ComputeRetentionTimeReference::maximum_intensity

Definition at line 135 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

m_seamarks

template<class T >

std::vector<MsRunRetentionTimeSeamarkPoint<T> > pappso::MsRunRetentionTime< T >::m_seamarks

private

Definition at line 130 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

m_valuesCorrected

template<class T >

std::size_t pappso::MsRunRetentionTime< T >::m_valuesCorrected = 0

private

Definition at line 131 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

mcsp_msrunId

template<class T >

pappso::MsRunIdCstSPtr pappso::MsRunRetentionTime< T >::mcsp_msrunId

private

Definition at line 126 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

msp_msrunReader

template<class T >

pappso::MsRunReaderSPtr pappso::MsRunRetentionTime< T >::msp_msrunReader

private

Definition at line 125 of file msrunretentiontime.h.

Referenced by pappso::MsRunRetentionTime< T >::MsRunRetentionTime().

---

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

• pappsomspp/msrun/alignment/msrunretentiontime.h
• pappsomspp/msrun/alignment/msrunretentiontime.cpp