#include <psmspecpeptidoms.h>

Inheritance diagram for pappso::cbor::psm::PsmSpecPeptidOmsScan:

Public Member Functions
	PsmSpecPeptidOmsScan (const PsmSpecPeptidOms &psm_specpeptidoms, pappso::PrecisionPtr fragment_tolerance)
virtual	~PsmSpecPeptidOmsScan ()
virtual void	filterAndSortPsmList () override
Public Member Functions inherited from pappso::cbor::psm::CborScanMapBase
	CborScanMapBase (const PsmFileScanProcess &psm_file_scan_process)
virtual	~CborScanMapBase ()
void	filterPsmListUniqueUniqueProforma ()
std::vector< double >::iterator	addPsmEvalVectorDouble (const QString &eval_name, const QString &eval_value_key, std::vector< double >::iterator begin, std::vector< double >::const_iterator end)
	add a new eval key and double values (from a vector) to each PSM
QCborMap	getCborScanId () const
QCborMap	getCborScanPrecursor () const
QCborArray	getCborPsmList () const
void	populateProteinMapUsingOldProteinMap (const PsmProteinMap &old_protein_map, PsmProteinMap &new_protein_map) const

Protected Member Functions
void	process () override
void	sequenceAlignment (bool is_reverse, const QCborMap &old_cbor_psm_map, QCborArray &new_psm_arr, pappso::specpeptidoms::SpOMSSpectrumCsp &experimental_spectrum, pappso::specpeptidoms::SemiGlobalAlignment &semi_global_alignment, const pappso::specpeptidoms::SpOMSProtein *protein_ptr)
void	storeAlignment (bool is_reverse, const QCborMap &old_cbor_psm, QCborMap &new_cbor_psm, const QString &accession, const pappso::specpeptidoms::Alignment &alignment)
void	fixPositionStart (bool is_reverse, QCborMap &new_cbor_psm, std::size_t offset_position) const
Protected Member Functions inherited from pappso::cbor::psm::CborScanMapBase
pappso::QualifiedMassSpectrumSPtr	getCurrentQualifiedMassSpectrumSPtr () const

Private Attributes
const PsmSpecPeptidOms *	mp_psmSpecPeptidOms
QString	m_decoyPrefix

Additional Inherited Members
Protected Attributes inherited from pappso::cbor::psm::CborScanMapBase
const PsmFileScanProcess &	m_PsmFileScanProcess

Detailed Description

Definition at line 99 of file psmspecpeptidoms.h.

Constructor & Destructor Documentation

◆ PsmSpecPeptidOmsScan()

pappso::cbor::psm::PsmSpecPeptidOmsScan::PsmSpecPeptidOmsScan	(	const PsmSpecPeptidOms &	psm_specpeptidoms,
		pappso::PrecisionPtr	fragment_tolerance )

Default constructor

Definition at line 145 of file psmspecpeptidoms.cpp.

  : CborScanMapBase(psm_specpeptidoms)
{
  mp_psmSpecPeptidOms = &psm_specpeptidoms;
 
  m_decoyPrefix = mp_psmSpecPeptidOms->m_decoyPrefix;
}

References pappso::cbor::psm::CborScanMapBase::CborScanMapBase(), m_decoyPrefix, and mp_psmSpecPeptidOms.

◆ ~PsmSpecPeptidOmsScan()

pappso::cbor::psm::PsmSpecPeptidOmsScan::~PsmSpecPeptidOmsScan ( )

virtual

Destructor

Definition at line 155 of file psmspecpeptidoms.cpp.

156{

157}

Member Function Documentation

◆ filterAndSortPsmList()

void pappso::cbor::psm::PsmSpecPeptidOmsScan::filterAndSortPsmList ( )

overridevirtual

Reimplemented from pappso::cbor::psm::CborScanMapBase.

Definition at line 355 of file psmspecpeptidoms.cpp.

{
  std::size_t max_psm = mp_psmSpecPeptidOms->m_maxInterpretationsPerSpectrum;
 
 
  struct sortPsmResults
  {
    qint64 score;
    QCborMap psm;
  };
 
  QCborArray old_psm_arr = value("psm_list").toArray();
  QCborArray new_psm_arr;
  // for(QCborValue cbor_psm : old_psm_arr) {
 
 
  std::vector<sortPsmResults> sort_psm_list;
  for(auto it_psm : old_psm_arr)
    {
      QCborMap psm_map = it_psm.toMap();
      qint64 score =
        psm_map.value("eval").toMap().value("peptidoms").toMap().value("score").toInteger();
      sort_psm_list.push_back({score, psm_map});
    }
  qDebug();
  std::sort(sort_psm_list.begin(), sort_psm_list.end(), [](sortPsmResults &a, sortPsmResults &b) {
    return a.score > b.score;
  });
 
 
  auto it_end = sort_psm_list.begin() + max_psm;
 
 
  qDebug() << sort_psm_list.size();
  for(auto it = sort_psm_list.begin(); it != sort_psm_list.end() && it != it_end; it++)
    {
 
      new_psm_arr.append(it->psm);
      qDebug();
    }
 
  // qWarning() << new_psm_arr.size();
  remove(QString("psm_list"));
  insert(QString("psm_list"), new_psm_arr);
}

References pappso::a, pappso::b, and mp_psmSpecPeptidOms.

◆ fixPositionStart()

void pappso::cbor::psm::PsmSpecPeptidOmsScan::fixPositionStart	(	bool	is_reverse,
		QCborMap &	new_cbor_psm,
		std::size_t	offset_position ) const

protected

Definition at line 481 of file psmspecpeptidoms.cpp.

{
  QCborArray new_protein_list;
  for(auto qcbor_protein : new_cbor_psm.value("protein_list").toArray())
    {
      QCborMap protein;
 
      QCborArray positions;
      if(is_reverse)
        {
          protein.insert(QString("accession"),
                         m_decoyPrefix + qcbor_protein.toMap().value("accession").toString());
          for(auto position : qcbor_protein.toMap().value("positions").toArray())
            {
              positions.append(position.toInteger() + (qint64)offset_position);
            }
        }
      else
        {
 
          protein.insert(QString("accession"), qcbor_protein.toMap().value("accession"));
          for(auto position : qcbor_protein.toMap().value("positions").toArray())
            {
              positions.append(position.toInteger() + (qint64)offset_position);
            }
        }
 
      protein.insert(QString("positions"), positions.toCborValue());
 
      new_protein_list.append(protein);
    }
  new_cbor_psm.insert(QString("protein_list"), new_protein_list);
}

References m_decoyPrefix.

Referenced by storeAlignment().

◆ process()

void pappso::cbor::psm::PsmSpecPeptidOmsScan::process ( )

overrideprotectedvirtual

Reimplemented from pappso::cbor::psm::CborScanMapBase.

Definition at line 160 of file psmspecpeptidoms.cpp.

{
  // qWarning() << "PsmSpecPeptidOmsScan::process " << keys();
  if(!keys().contains("id"))
    {
      throw pappso::PappsoException(QObject::tr("missing scan id"));
    }
  if(keys().contains("psm_list"))
    {
      QualifiedMassSpectrumSPtr qualified_mass_spectrum = getCurrentQualifiedMassSpectrumSPtr();
 
      // qWarning() << "PsmSpecPeptidOmsScan::process "
      //            << qualified_mass_spectrum.get()->getMassSpectrumId().getSpectrumIndex();
 
      mp_psmSpecPeptidOms->filterMassSpectrum(
        *(qualified_mass_spectrum.get()->getMassSpectrumSPtr().get()));
 
      pappso::specpeptidoms::SpOMSSpectrumCsp experimental_spectrum =
        std::make_shared<pappso::specpeptidoms::SpOMSSpectrum>(
          *qualified_mass_spectrum.get(),
          mp_psmSpecPeptidOms->m_fragmentTolerance,
          mp_psmSpecPeptidOms->getAaCode());
 
 
      pappso::specpeptidoms::SemiGlobalAlignment semi_global_alignment(
        mp_psmSpecPeptidOms->m_scoreValues,
        mp_psmSpecPeptidOms->m_fragmentTolerance,
        mp_psmSpecPeptidOms->m_aaCode);
 
 
      QCborArray new_psm_arr;
      for(QCborValue cbor_psm : value("psm_list").toArray())
        {
          QCborMap old_cbor_psm_map = cbor_psm.toMap();
 
 
          if(!old_cbor_psm_map.keys().contains("proforma"))
            {
              throw pappso::PappsoException(
                QObject::tr("missing proforma in psm %1").arg(old_cbor_psm_map.keys().size()));
            }
          pappso::PeptideSp peptide_sp = pappso::PeptideProFormaParser::parseString(
            old_cbor_psm_map.value("proforma").toString());
 
 
          pappso::specpeptidoms::SpOMSProtein protein(old_cbor_psm_map.value("proforma").toString(),
                                                      peptide_sp.get()->getSequence(),
                                                      mp_psmSpecPeptidOms->m_aaCode);
 
          sequenceAlignment(false,
                            old_cbor_psm_map,
                            new_psm_arr,
                            experimental_spectrum,
                            semi_global_alignment,
                            &protein);
 
          if(!m_decoyPrefix.isEmpty())
            {
              QString sequence = peptide_sp.get()->getSequence();
              std::reverse(sequence.begin(), sequence.end());
 
              pappso::specpeptidoms::SpOMSProtein protein_rev(
                m_decoyPrefix + old_cbor_psm_map.value("proforma").toString(),
                sequence,
                mp_psmSpecPeptidOms->m_aaCode);
 
              sequenceAlignment(true,
                                old_cbor_psm_map,
                                new_psm_arr,
                                experimental_spectrum,
                                semi_global_alignment,
                                &protein_rev);
            }
 
 
          // qWarning() << "new_psm_arr.size()=" << new_psm_arr.size();
        }
 
      // insert(QString("psm_list"), new_psm_arr);
      remove(QString("psm_list"));
      insert(QString("psm_list"), new_psm_arr);
 
      filterPsmListUniqueUniqueProforma();
    }
  // qWarning() << "PsmSpecPeptidOmsScan::process end";
}

References pappso::cbor::psm::CborScanMapBase::filterPsmListUniqueUniqueProforma(), pappso::cbor::psm::CborScanMapBase::getCurrentQualifiedMassSpectrumSPtr(), m_decoyPrefix, mp_psmSpecPeptidOms, pappso::PeptideProFormaParser::parseString(), and sequenceAlignment().

◆ sequenceAlignment()

void pappso::cbor::psm::PsmSpecPeptidOmsScan::sequenceAlignment	(	bool	is_reverse,
		const QCborMap &	old_cbor_psm_map,
		QCborArray &	new_psm_arr,
		pappso::specpeptidoms::SpOMSSpectrumCsp &	experimental_spectrum,
		pappso::specpeptidoms::SemiGlobalAlignment &	semi_global_alignment,
		const pappso::specpeptidoms::SpOMSProtein *	protein_ptr )

protected

Definition at line 249 of file psmspecpeptidoms.cpp.

{
 
  std::vector<pappso::specpeptidoms::Location> locations;
  std::vector<double> potential_mass_errors;
  const QString &sequence = protein_ptr->getSequence();
  // qWarning() << "PsmSpecPeptidOmsScan::process " << peptide_sequence;
  //  do not take into account peptide containing too much redundancy
  if(pappso::specpeptidoms::SemiGlobalAlignment::checkSequenceDiversity(sequence, 5, 2))
    {
      if((sequence.size() >= 8) &&
         (!pappso::specpeptidoms::SemiGlobalAlignment::checkSequenceDiversity(sequence, 8, 3)))
        return;
 
      semi_global_alignment.fastAlign(*experimental_spectrum.get(), protein_ptr);
      // qDebug() << "Completed fastAlign";
      locations = semi_global_alignment.getLocationSaver().getLocations();
 
      qDebug() << "locations.size():" << locations.size();
      for(auto loc : locations)
        {
          QCborMap new_cbor_psm;
          qDebug() << "beginning=" << loc.beginning << "length=" << loc.length
                   << "tree=" << loc.tree << "score=" << loc.score
                   << "protein=" << loc.proteinPtr->getAccession();
          semi_global_alignment.preciseAlign(
            *experimental_spectrum.get(), loc.proteinPtr, loc.beginning, loc.length);
          qDebug() << "Completed preciseAlign";
 
          pappso::specpeptidoms::Alignment best_alignment =
            semi_global_alignment.getBestAlignment();
          /*  qDebug() << "Best alignment" << best_alignment.interpretation
                     << best_alignment.score << "SPC" << best_alignment.SPC
                     << "beginning" << best_alignment.beginning << "end"
                     << best_alignment.end;*/
          if(best_alignment.end > (std::size_t)sequence.size())
            {
              throw pappso::ExceptionOutOfRange(QString("best_alignment.end > "
                                                        "(std::size_t)sequence.size() : %1 %2")
                                                  .arg(best_alignment.end)
                                                  .arg(sequence.size()));
            }
          if(best_alignment.begin_shift > 0 || best_alignment.end_shift > 0 ||
             best_alignment.shifts.size() > 0)
            {
              qDebug();
              potential_mass_errors =
                pappso::specpeptidoms::SemiGlobalAlignment::getPotentialMassErrors(
                  mp_psmSpecPeptidOms->m_aaCode, best_alignment, sequence);
              qDebug();
              semi_global_alignment.postProcessingAlign(*experimental_spectrum.get(),
                                                        loc.proteinPtr,
                                                        loc.beginning,
                                                        loc.length,
                                                        potential_mass_errors);
 
              qDebug() << "semi_global_alignment.getBestAlignment()";
              pappso::specpeptidoms::Alignment best_post_processed_alignment =
                semi_global_alignment.getBestAlignment();
              if(best_post_processed_alignment.SPC > best_alignment.SPC)
                {
                  qDebug() << "Best post-processed alignment"
                           << best_post_processed_alignment.m_peptideModel.toInterpretation()
                           << best_post_processed_alignment.score << "SPC"
                           << best_post_processed_alignment.SPC;
                  storeAlignment(is_reverse,
                                 old_cbor_psm_map,
                                 new_cbor_psm,
                                 protein_ptr->getAccession(),
                                 best_post_processed_alignment);
                }
              else
                {
                  qDebug() << "no improvement in post-processing";
                  storeAlignment(is_reverse,
                                 old_cbor_psm_map,
                                 new_cbor_psm,
                                 protein_ptr->getAccession(),
                                 best_alignment);
                }
            }
          else
            {
 
              storeAlignment(is_reverse,
                             old_cbor_psm_map,
                             new_cbor_psm,
                             protein_ptr->getAccession(),
                             best_alignment);
            }
 
          if(!new_cbor_psm.isEmpty())
            {
              new_psm_arr.push_back(new_cbor_psm);
            }
        }
    }
}

Referenced by process().

◆ storeAlignment()

void pappso::cbor::psm::PsmSpecPeptidOmsScan::storeAlignment	(	bool	is_reverse,
		const QCborMap &	old_cbor_psm,
		QCborMap &	new_cbor_psm,
		const QString &	accession,
		const pappso::specpeptidoms::Alignment &	alignment )

protected

Definition at line 403 of file psmspecpeptidoms.cpp.

{
  qDebug() << accession;
 
  if(alignment.score > 0)
    {
 
      QString peptide_key(alignment.m_peptideModel.toProForma());
 
 
      /*
 
    {"proforma":"LHGAGADDADADD",
    "protein_list":
    [{
        "accession": "GRMZM2G108267_P01",
        "positions": [
            337
        ]
    }
    {
        "accession": "GRMZM2G108267_P02",
        "positions": [
            337
        ]
    }
    ]
    ,
    "eval":{
        "matcher": {
            "score": 193077
        }
    }
    }
    */
 
      // do not take into account peptide containing too much redundancy
      if(pappso::specpeptidoms::SemiGlobalAlignment::checkSequenceDiversity(peptide_key, 5, 2))
        {
          // qDebug() << "peptide_key=" << peptide_key;
          new_cbor_psm.insert(QString("proforma"), peptide_key);
 
          // copy protein list in new psm
          new_cbor_psm.insert(QString("protein_list"), old_cbor_psm.value("protein_list"));
 
          fixPositionStart(is_reverse, new_cbor_psm, alignment.getPositionStart());
 
          QCborMap cbor_eval;
 
          QCborMap cbor_peptidoms;
 
          // auto it_protein_pos =
          //  one_peptide_result.map_protein2positions.insert({accession, QCborArray()});
          // it_protein_pos.first->second.append((qint64)alignment.getPositionStart());
 
          cbor_peptidoms.insert(QString("bracket"), alignment.m_peptideModel.toInterpretation());
          cbor_peptidoms.insert(QString("spc"), (qint64)alignment.SPC);
          cbor_peptidoms.insert(QString("score"), alignment.score);
          cbor_peptidoms.insert(QString("nam"), alignment.getNonAlignedMass());
 
 
          // copy matcher eval in new psm
          cbor_eval.insert(QString("matcher"), old_cbor_psm.value("eval").toMap().value("matcher"));
 
 
          // store peptidoms eval in new psm
          cbor_eval.insert(QString("peptidoms"), cbor_peptidoms);
 
          new_cbor_psm.insert(QString("eval"), cbor_eval);
        }
    }
}

References pappso::specpeptidoms::SemiGlobalAlignment::checkSequenceDiversity(), fixPositionStart(), pappso::specpeptidoms::Alignment::getNonAlignedMass(), pappso::specpeptidoms::Alignment::getPositionStart(), pappso::specpeptidoms::Alignment::m_peptideModel, pappso::specpeptidoms::Alignment::score, pappso::specpeptidoms::Alignment::SPC, pappso::specpeptidoms::PeptideModel::toInterpretation(), and pappso::specpeptidoms::PeptideModel::toProForma().

Referenced by sequenceAlignment().

Member Data Documentation

◆ m_decoyPrefix

QString pappso::cbor::psm::PsmSpecPeptidOmsScan::m_decoyPrefix

private

Definition at line 136 of file psmspecpeptidoms.h.

Referenced by PsmSpecPeptidOmsScan(), fixPositionStart(), and process().

◆ mp_psmSpecPeptidOms

const PsmSpecPeptidOms* pappso::cbor::psm::PsmSpecPeptidOmsScan::mp_psmSpecPeptidOms

private

Definition at line 135 of file psmspecpeptidoms.h.

Referenced by PsmSpecPeptidOmsScan(), filterAndSortPsmList(), process(), and sequenceAlignment().

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

pappsomspp/core/processing/cbor/psm/evalscan/psmspecpeptidoms.h
pappsomspp/core/processing/cbor/psm/evalscan/psmspecpeptidoms.cpp

Public Member Functions

Protected Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PsmSpecPeptidOmsScan()

◆ ~PsmSpecPeptidOmsScan()

Member Function Documentation

◆ filterAndSortPsmList()

◆ fixPositionStart()

◆ process()

◆ sequenceAlignment()

◆ storeAlignment()

Member Data Documentation

◆ m_decoyPrefix

◆ mp_psmSpecPeptidOms