#include <timsframe.h>

Inheritance diagram for pappso::TimsFrame:

Public Member Functions
	TimsFrame (std::size_t timsId, quint32 scanNum, char *p_bytes, std::size_t len)

	TimsFrame (const TimsFrame &other)

	~TimsFrame ()

virtual std::size_t	getNbrPeaks (std::size_t scanNum) const override

virtual Trace	cumulateScanToTrace (std::size_t scanNumBegin, std::size_t scanNumEnd) const override
	cumulate scan list into a trace More...

std::vector< quint32 >	getScanIndexList (std::size_t scanNum) const
	get raw index list for one given scan index are not TOF nor m/z, just index on digitizer More...

std::vector< quint32 >	getScanIntensities (std::size_t scanNum) const
	get raw intensities without transformation from one scan it needs intensity normalization More...

pappso::MassSpectrumCstSPtr	getMassSpectrumCstSPtr (std::size_t scanNum) const
	get the mass spectrum corresponding to a scan number More...

virtual pappso::MassSpectrumSPtr	getMassSpectrumSPtr (std::size_t scanNum) const override

pappso::Trace	getTraceFromCumulatedScans (std::map< quint32, quint32 > &accumulated_scans) const
	transform accumulation of raw scans into a real mass spectrum More...

Public Member Functions inherited from pappso::TimsFrameBase
	TimsFrameBase (std::size_t timsId, quint32 scanNum)
	constructor for binary independant tims frame More...

	TimsFrameBase (const TimsFrameBase &other)

	~TimsFrameBase ()

bool	checkScanNum (std::size_t scanNum) const

void	setAccumulationTime (double accumulation_time_ms)

void	setMzCalibration (double temperature_correction, double digitizerTimebase, double digitizerDelay, double C0, double C1, double C2, double C3)

void	setTimsCalibration (int tims_model_type, double C0, double C1, double C2, double C3, double C4, double C5, double C6, double C7, double C8, double C9)

void	setTime (double time)

void	setMsMsType (quint8 type)

unsigned int	getMsLevel () const

double	getTime () const

std::size_t	getId () const

double	getDriftTime (std::size_t scanNum) const
	get drift time of a scan number in milliseconds More...

double	getOneOverK0Transformation (std::size_t scanNum) const
	get 1/K0 value of a given scan (mobility value) More...

double	getMzFromTof (double tof) const
	get m/z from time of flight More...

quint32	getRawIndexFromMz (double mz) const
	get raw index of a given m/z More...

double	getVoltageTransformation (std::size_t scanNum) const

double	getTofFromIndex (quint32 index) const
	get time of flight from raw index More...

double	getTofFromIndex (double index) const
	get time of flight from double index More...

Protected Member Functions
void	extractTimsXicListInRtRange (std::vector< TimsXicStructure >::iterator &itXicListbegin, std::vector< TimsXicStructure >::iterator &itXicListend, XicExtractMethod method) const

Private Member Functions
void	unshufflePacket (const char *src)

std::size_t	getScanOffset (std::size_t scanNum) const

void	cumulateScan (std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into) const
	cumulate a scan into a map More...

Private Attributes
friend	TimsDirectXicExtractor

QByteArray	m_timsDataFrame

Additional Inherited Members
Protected Attributes inherited from pappso::TimsFrameBase
quint32	m_scanNumber
	total number of scans contained in this frame More...

std::size_t	m_timsId
	Tims frame database id (the SQL identifier of this frame) More...

double	m_accumulationTime = 0
	accumulation time in milliseconds More...

double	m_digitizerTimebase = 0

double	m_digitizerDelay = 0

std::vector< double >	m_mzCalibrationArr
	MZ calibration parameters. More...

quint8	m_msMsType = 0

double	m_time = 0
	retention time More...

double	m_timsDvStart = 0

double	m_timsSlope

double	m_timsTtrans = 0

double	m_timsNdelay = 0

double	m_timsVmin = 0

double	m_timsVmax = 0

double	m_timsC6 = 0

double	m_timsC7 = 0

Detailed Description

Todo:: write docs

Definition at line 67 of file timsframe.h.

Constructor & Destructor Documentation

◆ TimsFrame() [1/2]

pappso::TimsFrame::TimsFrame	(	std::size_t	timsId,
		quint32	scanNum,
		char *	p_bytes,
		std::size_t	len
	)

Default constructor

Definition at line 58 of file timsframe.cpp.

     {
       if(m_scanNumber == 0)
         {
  
           throw pappso::PappsoException(
             QObject::tr("TimsFrame::TimsFrame(%1,%2,nullptr,%3) FAILED")
               .arg(m_timsId)
               .arg(m_scanNumber)
               .arg(len));
         }
     }
 }
  
 TimsFrame::TimsFrame(const TimsFrame &other) : TimsFrameBase(other)
 {
 }
  
 TimsFrame::~TimsFrame()
 {
 }
  
  
 void
 TimsFrame::unshufflePacket(const char *src)
 {
   qDebug();
   quint64 len = m_timsDataFrame.size();
   if(len % 4 != 0)
     {

◆ TimsFrame() [2/2]

pappso::TimsFrame::TimsFrame ( const TimsFrame & other )

Copy constructor

Parameters

other TODO

Definition at line 89 of file timsframe.cpp.

                                                  : len%4 != 0"));
     }
  

◆ ~TimsFrame()

pappso::TimsFrame::~TimsFrame ( )

Destructor

Definition at line 93 of file timsframe.cpp.

98 {

Member Function Documentation

◆ cumulateScan()

void pappso::TimsFrame::cumulateScan	(	std::size_t	scanNum,
		std::map< quint32, quint32 > &	accumulate_into
	)		const

private

cumulate a scan into a map

Definition at line 217 of file timsframe.cpp.

         {
           // already existed : cumulate
           ret.first->second += y;
         }
     }
   qDebug();
 }
  
  
 Trace
 TimsFrame::cumulateScanToTrace(std::size_t scanNumBegin,
                                std::size_t scanNumEnd) const
 {
   qDebug();
   try
     {
       Trace new_trace;
       if(m_timsDataFrame.size() == 0)
         return new_trace;
       std::map<quint32, quint32> raw_spectrum;
       // double local_accumulationTime = 0;
  
       std::size_t imax = scanNumEnd + 1;
       qDebug();

References pappso::y.

◆ cumulateScanToTrace()

Trace pappso::TimsFrame::cumulateScanToTrace	(	std::size_t	scanNumBegin,
		std::size_t	scanNumEnd
	)		const

overridevirtual

cumulate scan list into a trace

Reimplemented from pappso::TimsFrameBase.

Definition at line 255 of file timsframe.cpp.

                                                        : raw_spectrum)
         {
           data_point_cumul.x =
             getMzFromTof(getTofFromIndex(pair_tof_intensity.first));
           // normalization
           data_point_cumul.y =
             pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
           new_trace.push_back(data_point_cumul);
         }
       new_trace.sortX();
       qDebug();
       return new_trace;
     }
  
   catch(std::exception &error)
     {
       qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
                << QString(
                     "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
                     .arg(scanNumBegin, scanNumEnd)
                     .arg(error.what());
     }
 }
  
  
 pappso::Trace
 TimsFrame::getTraceFromCumulatedScans(
   std::map<quint32, quint32> &accumulated_scans) const
 {
   qDebug();
   // qDebug();
   // add flanking peaks
   std::vector<quint32> keys;
   transform(begin(accumulated_scans),
             end(accumulated_scans),
             back_inserter(keys),
             [](std::map<quint32, quint32>::value_type const &pair) {
               return pair.first;
             });
   std::sort(keys.begin(), keys.end());

◆ extractTimsXicListInRtRange()

void pappso::TimsFrame::extractTimsXicListInRtRange	(	std::vector< TimsXicStructure >::iterator &	itXicListbegin,
		std::vector< TimsXicStructure >::iterator &	itXicListend,
		XicExtractMethod	method
	)		const

protected

Definition at line 478 of file timsframe.cpp.

     {
       for(std::size_t scan = struct_xic.mobilityIndexBegin;
           scan <= struct_xic.mobilityIndexEnd;
           scan++)
         {
           unique_scan_num_list.push_back(scan);
         }
     }
   std::sort(unique_scan_num_list.begin(), unique_scan_num_list.end());
   auto it_scan_num_end =
     std::unique(unique_scan_num_list.begin(), unique_scan_num_list.end());
   auto it_scan_num = unique_scan_num_list.begin();
  
   while(it_scan_num != it_scan_num_end)
     {
       MassSpectrumCstSPtr ms_spectrum = getMassSpectrumCstSPtr(*it_scan_num);
       for(auto &&tmp_xic_struct : tmp_xic_list)
         {
           if(((*it_scan_num) >= tmp_xic_struct.mobilityIndexBegin) &&
              ((*it_scan_num) <= tmp_xic_struct.mobilityIndexEnd))
             {
               if(method == XicExtractMethod::max)
                 {
                   tmp_xic_struct.tmpIntensity +=
                     ms_spectrum.get()->maxY(tmp_xic_struct.mzRange.lower(),
                                             tmp_xic_struct.mzRange.upper());
                 }
               else
                 {
                   // sum
                   tmp_xic_struct.tmpIntensity +=
                     ms_spectrum.get()->sumY(tmp_xic_struct.mzRange.lower(),
                                             tmp_xic_struct.mzRange.upper());
                 }
             }
         }
       it_scan_num++;
     }
  
   for(auto &&tmp_xic_struct : tmp_xic_list)
     {
       if(tmp_xic_struct.tmpIntensity != 0)
         {
           tmp_xic_struct.xicSptr.get()->push_back(
             {m_time, tmp_xic_struct.tmpIntensity});
         }
     }
 }
  
 } // namespace pappso

◆ getMassSpectrumCstSPtr()

pappso::MassSpectrumCstSPtr pappso::TimsFrame::getMassSpectrumCstSPtr ( std::size_t scanNum ) const

get the mass spectrum corresponding to a scan number

Parameters

scanNum the scan number to retrieve

Definition at line 423 of file timsframe.cpp.

◆ getMassSpectrumSPtr()

pappso::MassSpectrumSPtr pappso::TimsFrame::getMassSpectrumSPtr ( std::size_t scanNum ) const

overridevirtual

Reimplemented from pappso::TimsFrameBase.

Definition at line 430 of file timsframe.cpp.

     {
       DataPoint data_point(
         (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
          previous),
         (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
                       4)));
  
       // intensity normalization
       data_point.y *= 100.0 / m_accumulationTime;
  
       previous = data_point.x;
  
  
       // mz calibration
       double tof   = (data_point.x * m_digitizerTimebase) + m_digitizerDelay;
       data_point.x = getMzFromTof(tof);
       mass_spectrum_sptr.get()->push_back(data_point);
     }
   qDebug();
   return mass_spectrum_sptr;
 }
  
  
 void
 TimsFrame::extractTimsXicListInRtRange(
   std::vector<TimsXicStructure>::iterator &itXicListbegin,
   std::vector<TimsXicStructure>::iterator &itXicListend,
   XicExtractMethod method) const
 {
   std::vector<TimsXicStructure> tmp_xic_list(itXicListbegin, itXicListend);
  
   if(tmp_xic_list.size() == 0)
     return;
   /*
   std::sort(tmp_xic_list.begin(), tmp_xic_list.end(), [](const TimsXicStructure
   &a, const TimsXicStructure &b) { return a.mobilityIndexBegin <
   b.mobilityIndexBegin;
             });

◆ getNbrPeaks()

std::size_t pappso::TimsFrame::getNbrPeaks ( std::size_t scanNum ) const

overridevirtual

Reimplemented from pappso::TimsFrameBase.

Definition at line 126 of file timsframe.cpp.

         {
           cumul += (*(quint32 *)(m_timsDataFrame.constData() + (i * 4)));
         }
       return (nb_uint4 - cumul) / 2;
     }
   checkScanNum(scanNum);
  
   // quint32 *res = (quint32 *)(m_timsDataFrame.constData() + (scanNum * 4));
   // qDebug() << " res=" << *res;
   return (*(quint32 *)(m_timsDataFrame.constData() + ((scanNum + 1) * 4))) / 2;
 }
  
 std::size_t
 TimsFrame::getScanOffset(std::size_t scanNum) const
 {
   std::size_t offset = 0;
   for(std::size_t i = 0; i < (scanNum + 1); i++)
     {
       offset += (*(quint32 *)(m_timsDataFrame.constData() + (i * 4)));
     }
   return offset;
 }
  
  
 std::vector<quint32>
 TimsFrame::getScanIndexList(std::size_t scanNum) const
 {
   qDebug();

References m_timsDataFrame.

◆ getScanIndexList()

std::vector< quint32 > pappso::TimsFrame::getScanIndexList ( std::size_t scanNum ) const

get raw index list for one given scan index are not TOF nor m/z, just index on digitizer

Definition at line 168 of file timsframe.cpp.

 {
   qDebug();
   checkScanNum(scanNum);
   std::vector<quint32> scan_intensities;
  
   if(m_timsDataFrame.size() == 0)
     return scan_intensities;
  
   scan_intensities.resize(getNbrPeaks(scanNum));
  
   std::size_t offset = getScanOffset(scanNum);
  
   for(std::size_t i = 0; i < scan_intensities.size(); i++)
     {

◆ getScanIntensities()

std::vector< quint32 > pappso::TimsFrame::getScanIntensities ( std::size_t scanNum ) const

get raw intensities without transformation from one scan it needs intensity normalization

Definition at line 193 of file timsframe.cpp.

 {
   qDebug();
  
   if(m_timsDataFrame.size() == 0)
     return;
   checkScanNum(scanNum);
  
   std::size_t size = getNbrPeaks(scanNum);
  
   std::size_t offset = getScanOffset(scanNum);

◆ getScanOffset()

std::size_t pappso::TimsFrame::getScanOffset ( std::size_t scanNum ) const

private

Definition at line 156 of file timsframe.cpp.

165 {

◆ getTraceFromCumulatedScans()

pappso::Trace pappso::TimsFrame::getTraceFromCumulatedScans ( std::map< quint32, quint32 > & accumulated_scans ) const

transform accumulation of raw scans into a real mass spectrum

Definition at line 305 of file timsframe.cpp.

                   : keys)
     {
       if((key - previous) > hole_width)
         {
  
           // qDebug() << " key:" << key << " previous:" << previous
           //       << " (key - previous):" << (key - previous);
           if(data_point_cumul.x != 0)
             {
               data_point_cumul.x = data_point_cumul.x / data_point_cumul.y;
  
               data_point_cumul.x =
                 getMzFromTof(getTofFromIndex(data_point_cumul.x));
               // normalization
               data_point_cumul.y =
                 data_point_cumul.y * ((double)100.0 / m_accumulationTime);
               local_trace.push_back(data_point_cumul);
             }
           // reset
           data_point_cumul.x = 0;
           data_point_cumul.y = 0;
           previous_intensity = 0;
           go_up              = true;
         }
       double intensity = accumulated_scans[key];
  
       if(previous_intensity < intensity)
         {
           if(!go_up)
             {
               // stop
               data_point_cumul.x = data_point_cumul.x / data_point_cumul.y;
  
               data_point_cumul.x =
                 getMzFromTof(getTofFromIndex(data_point_cumul.x));
               // normalization
               data_point_cumul.y =
                 data_point_cumul.y * ((double)100.0 / m_accumulationTime);
               local_trace.push_back(data_point_cumul);
  
               // reset
               data_point_cumul.x = 0;
               data_point_cumul.y = 0;
               previous_intensity = 0;
               go_up              = true;
             }
         }
       else
         {
           if(go_up)
             {
               go_up = false;
             }
           else
             {
             }
         }
  
  
       data_point_cumul.x += ((double)key * intensity);
       data_point_cumul.y += intensity;
       previous           = key;
       previous_intensity = intensity;
     }
  
  
   if(data_point_cumul.x != 0)
     {
       data_point_cumul.x = data_point_cumul.x / data_point_cumul.y;
  
       data_point_cumul.x = getMzFromTof(getTofFromIndex(data_point_cumul.x));
       // normalization
       data_point_cumul.y =
         data_point_cumul.y * ((double)100.0 / m_accumulationTime);
       local_trace.push_back(data_point_cumul);
     }
   local_trace.sortX();
   qDebug();
   // qDebug();
   return local_trace;
 }
  
 pappso::MassSpectrumCstSPtr
 TimsFrame::getMassSpectrumCstSPtr(std::size_t scanNum) const
 {
   qDebug();
   return getMassSpectrumSPtr(scanNum);
 }
  
 pappso::MassSpectrumSPtr
 TimsFrame::getMassSpectrumSPtr(std::size_t scanNum) const
 {
  
   qDebug() << " scanNum=" << scanNum;
  
   checkScanNum(scanNum);
  
   qDebug();

References pappso::TimsFrameBase::getMzFromTof(), pappso::TimsFrameBase::getTofFromIndex(), and pappso::TimsFrameBase::m_accumulationTime.

◆ unshufflePacket()

void pappso::TimsFrame::unshufflePacket ( const char * src )

private

Definition at line 99 of file timsframe.cpp.

         {
           dest[(i * 4) + j] = src[src_offset];
           src_offset++;
         }
     }
   qDebug();
 }
  
 std::size_t
 TimsFrame::getNbrPeaks(std::size_t scanNum) const
 {
   if(m_timsDataFrame.size() == 0)
     return 0;
   /*
     if(scanNum == 0)
       {
         quint32 res = (*(quint32 *)(m_timsDataFrame.constData() + 4)) -
                       (*(quint32 *)(m_timsDataFrame.constData()-4));
         return res / 2;
       }*/
   if(scanNum == (m_scanNumber - 1))
     {
       auto nb_uint4 = m_timsDataFrame.size() / 4;
  

Member Data Documentation

◆ m_timsDataFrame

QByteArray pappso::TimsFrame::m_timsDataFrame

private

Definition at line 141 of file timsframe.h.

Referenced by getNbrPeaks().

◆ TimsDirectXicExtractor

friend pappso::TimsFrame::TimsDirectXicExtractor

private

Definition at line 69 of file timsframe.h.

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

pappsomspp/vendors/tims/timsframe.h
pappsomspp/vendors/tims/timsframe.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TimsFrame() [1/2]

◆ TimsFrame() [2/2]

◆ ~TimsFrame()

Member Function Documentation

◆ cumulateScan()

◆ cumulateScanToTrace()

◆ extractTimsXicListInRtRange()

◆ getMassSpectrumCstSPtr()

◆ getMassSpectrumSPtr()

◆ getNbrPeaks()

◆ getScanIndexList()

◆ getScanIntensities()

◆ getScanOffset()

◆ getTraceFromCumulatedScans()

◆ unshufflePacket()

Member Data Documentation

◆ m_timsDataFrame

◆ TimsDirectXicExtractor