libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
pappso::TimsFrame Class Reference

#include <timsframe.h>

Inheritance diagram for pappso::TimsFrame:
pappso::TimsFrameBase pappso::TimsFrameType1

Classes

struct  XicComputeStructure
 

Public Member Functions

 TimsFrame (std::size_t timsId, quint32 scanNum, char *p_bytes, std::size_t len)
 
 TimsFrame (const TimsFrame &other)
 
virtual ~TimsFrame ()
 
virtual std::size_t getNbrPeaks (std::size_t scanNum) const override
 get the number of peaks in this spectrum need the binary file
 
virtual Trace cumulateScansToTrace (std::size_t scanNumBegin, std::size_t scanNumEnd) const override
 cumulate scan list into a trace
 
virtual Trace cumulateScansToTraceMzDownResolution (std::size_t mzindex_merge_window, std::size_t scanNumBegin, std::size_t scanNumEnd, quint32 &mz_minimum_index, quint32 &mz_maximum_index) const override
 cumulate spectrum given a scan number range need the binary file The intensities are normalized with respect to the frame accumulation time to leverage computing performance, this function decreases the mz resolution
 
virtual Trace cumulateScansToTraceMzDownResolution2 (std::size_t mz_index_merge_window, double mz_range_begin, double mz_range_end, std::size_t mobility_scan_begin, std::size_t mobility_scan_end, quint32 &mz_minimum_index_out, quint32 &mz_maximum_index_out) const override
 cumulate spectrum given a scan number range need the binary file The intensities are normalized with respect to the frame accumulation time to leverage computing performance, this function decreases the mz resolution
 
virtual void cumulateScansInRawMap (std::map< quint32, quint32 > &rawSpectrum, std::size_t scanNumBegin, std::size_t scanNumEnd) const override
 cumulate scan list into a trace into a raw spectrum map
 
virtual Trace getMobilityScan (std::size_t scanNum, std::size_t mz_index_merge_window, double mz_range_begin, double mz_range_end, quint32 &mz_minimum_index_out, quint32 &mz_maximum_index_out) const override
 get a single mobility scan m/z + intensities
 
virtual quint64 cumulateSingleScanIntensities (std::size_t scanNum) const override
 
virtual quint64 cumulateScansIntensities (std::size_t scanNumBegin, std::size_t scanNumEnd) const override
 ...
 
virtual std::vector< quint32 > getScanIndexList (std::size_t scanNum) const override
 get raw index list for one given scan index are not TOF nor m/z, just index on digitizer
 
virtual std::vector< quint32 > getScanIntensities (std::size_t scanNum) const override
 get raw intensities without transformation from one scan it needs intensity normalization
 
virtual pappso::MassSpectrumSPtr getMassSpectrumSPtr (std::size_t scanNum) const override
 get Mass spectrum with peaks for this scan number need the binary file
 
- Public Member Functions inherited from pappso::TimsFrameBase
 TimsFrameBase (std::size_t timsId, quint32 scanNum)
 constructor for binary independant tims frame
 
 TimsFrameBase (const TimsFrameBase &other)
 
virtual ~TimsFrameBase ()
 
virtual bool hasSameCalibrationData (const TimsFrameBase &other) const
 tells if 2 tims frame has the same calibration data Usefull to know if raw data can be handled between frames
 
virtual std::size_t getTotalNumberOfScans () const
 get the number of scans contained in this frame each scan represents an ion mobility slice
 
virtual quint32 getMaximumRawMassIndex () const
 get the maximum raw mass index contained in this frame
 
virtual pappso::MassSpectrumCstSPtr getMassSpectrumCstSPtr (std::size_t scanNum) const final
 get the mass spectrum corresponding to a scan number
 
bool checkScanNum (std::size_t scanNum) const
 check that this scan number exists
 
void setAccumulationTime (double accumulation_time_ms)
 
void setMzCalibration (double T1_frame, double T2_frame, double digitizerTimebase, double digitizerDelay, double C0, double C1, double C2, double C3, double C4, double T1_ref, double T2_ref, double dC1, double dC2)
 
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
 
double getOneOverK0Transformation (std::size_t scanNum) const
 get 1/K0 value of a given scan (mobility value)
 
std::size_t getScanNumFromOneOverK0 (double one_over_k0) const
 get the scan number from a given 1/Ko mobility value
 
double getVoltageTransformation (std::size_t scanNum) const
 get voltage for a given scan number
 
pappso::Trace getTraceFromCumulatedScans (std::map< quint32, quint32 > &accumulated_scans) const
 transform accumulation of raw scans into a real mass spectrum
 
pappso::Trace getTraceFromCumulatedScansBuiltinCentroid (std::map< quint32, quint32 > &accumulated_scans) const
 transform accumulation of raw scans into a real mass spectrum with a simple centroid on raw integers
 
virtual const MzCalibrationInterfaceSPtrgetMzCalibrationInterfaceSPtr () const final
 get the MzCalibration model to compute mz and TOF for this frame
 
void setMzCalibrationInterfaceSPtr (MzCalibrationInterfaceSPtr mzCalibration)
 
virtual Trace getIonMobilityTraceByMzIndexRange (std::size_t mz_index_lower_bound, std::size_t mz_index_upper_bound, XicExtractMethod method) const
 get a mobility trace cumulating intensities inside the given mass index range
 

Protected Member Functions

 TimsFrame (std::size_t timsId, quint32 scanNum)
 constructor for binary independant tims frame
 
void extractTimsXicListInRtRange (std::vector< XicCoordTims * >::iterator &itXicListbegin, std::vector< XicCoordTims * >::iterator &itXicListend, XicExtractMethod method) const
 
virtual void cumulateScan (std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into) const
 cumulate a scan into a map
 
virtual void cumulateScan2 (std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const
 
virtual pappso::TraceSPtr getRawTraceSPtr (std::size_t scanNum) const
 get the raw index tof_index and intensities (normalized)
 
virtual std::vector< RawValuePairgetRawValuePairList (std::size_t scanNum, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const
 get the raw index tof_index and intensities (normalized)
 
- Protected Member Functions inherited from pappso::TimsFrameBase
virtual std::map< quint32, quint32 > & downsizeMzRawMap (std::size_t mzindex_merge_window, std::map< quint32, quint32 > &rawSpectrum) const
 downsize mz resolution to lower the number of real mz computations
 
virtual std::vector< RawValuePair > & downsizeMzRawValuePairList (std::size_t mzindex_merge_window, std::vector< RawValuePair > &spectrum) const
 downsize mz resolution to lower the number of real mz computations
 

Protected Attributes

QByteArray m_timsDataFrame
 
- Protected Attributes inherited from pappso::TimsFrameBase
quint32 m_scanNumber
 total number of scans contained in this frame
 
std::size_t m_timsId
 Tims frame database id (the SQL identifier of this frame)
 
double m_accumulationTime = 0
 accumulation time in milliseconds
 
quint8 m_msMsType = 0
 
double m_time = 0
 retention time
 
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
 
MzCalibrationInterfaceSPtr msp_mzCalibration = nullptr
 

Private Member Functions

void unshufflePacket (const char *src)
 unshuffle data packet of tims compression type 2
 
std::size_t getScanOffset (std::size_t scanNum) const
 get offset for this spectrum in the binary file
 

Private Attributes

friend TimsDirectXicExtractor
 

Detailed Description

Todo:
write docs

Definition at line 51 of file timsframe.h.

Constructor & Destructor Documentation

◆ TimsFrame() [1/3]

pappso::TimsFrame::TimsFrame ( std::size_t  timsId,
quint32  scanNum,
char *  p_bytes,
std::size_t  len 
)
Parameters
timsIdtims frame id
scanNumtotal number of scans in this frame
p_bytespointer on the decompressed binary buffer
lensize of the decompressed binary buffer

Definition at line 61 of file timsframe.cpp.

65 : TimsFrameBase(timsId, scanNum)
66{
67 // langella@themis:~/developpement/git/bruker/cbuild$
68 // ./src/sample/timsdataSamplePappso
69 // /gorgone/pappso/fichiers_fabricants/Bruker/Demo_TimsTOF_juin2019/Samples/1922001/1922001-1_S-415_Pep_Pur-1ul_Slot1-10_1_2088.d/
70 qDebug() << timsId;
71
72 m_timsDataFrame.resize(len);
73
74 if(p_bytes != nullptr)
75 {
76 unshufflePacket(p_bytes);
77 }
78 else
79 {
80 if(m_scanNumber == 0)
81 {
82
84 QObject::tr("TimsFrame::TimsFrame(%1,%2,nullptr,%3) FAILED")
85 .arg(m_timsId)
86 .arg(m_scanNumber)
87 .arg(len));
88 }
89 }
90}
TimsFrameBase(std::size_t timsId, quint32 scanNum)
constructor for binary independant tims frame
quint32 m_scanNumber
total number of scans contained in this frame
std::size_t m_timsId
Tims frame database id (the SQL identifier of this frame)
QByteArray m_timsDataFrame
Definition timsframe.h:279
void unshufflePacket(const char *src)
unshuffle data packet of tims compression type 2

References pappso::TimsFrameBase::m_scanNumber, m_timsDataFrame, pappso::TimsFrameBase::m_timsId, and unshufflePacket().

◆ TimsFrame() [2/3]

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

Copy constructor

Parameters
otherTODO

Definition at line 92 of file timsframe.cpp.

92 : TimsFrameBase(other)
93{
94}

◆ ~TimsFrame()

pappso::TimsFrame::~TimsFrame ( )
virtual

Destructor

Definition at line 96 of file timsframe.cpp.

97{
98}

◆ TimsFrame() [3/3]

pappso::TimsFrame::TimsFrame ( std::size_t  timsId,
quint32  scanNum 
)
protected

constructor for binary independant tims frame

Parameters
timsIdtims frame identifier in the database
scanNumthe total number of scans contained in this frame

Definition at line 55 of file timsframe.cpp.

56 : TimsFrameBase(timsId, scanNum)
57{
58 // m_timsDataFrame.resize(10);
59}

Member Function Documentation

◆ cumulateScan()

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

cumulate a scan into a map

Parameters
scanNumscan number 0 to (m_scanNumber-1)

Reimplemented in pappso::TimsFrameType1.

Definition at line 305 of file timsframe.cpp.

307{
308 // qDebug();
309
310 if(m_timsDataFrame.size() == 0)
311 return;
312
313 // checkScanNum(scanNum);
314
315 std::size_t scan_size = getNbrPeaks(scanNum);
316
317 std::size_t scan_offset = getScanOffset(scanNum);
318
319 qint32 previous = -1;
320 for(std::size_t i = 0; i < scan_size; i++)
321 {
322 quint32 x = (*(quint32 *)((m_timsDataFrame.constData() +
323 (scan_offset * 4) + (i * 8))) +
324 previous);
325 quint32 y = (*(quint32 *)(m_timsDataFrame.constData() +
326 (scan_offset * 4) + (i * 8) + 4));
327
328 previous = x;
329
330 auto ret = accumulate_into.insert(std::pair<quint32, quint32>(x, y));
331
332 if(ret.second == false)
333 {
334 // already existed : cumulate
335 ret.first->second += y;
336 }
337 }
338
339 // qDebug();
340}
virtual std::size_t getNbrPeaks(std::size_t scanNum) const override
get the number of peaks in this spectrum need the binary file
std::size_t getScanOffset(std::size_t scanNum) const
get offset for this spectrum in the binary file

References getNbrPeaks(), getScanOffset(), m_timsDataFrame, pappso::x, and pappso::y.

Referenced by cumulateScansInRawMap(), cumulateScansToTrace(), and cumulateScansToTraceMzDownResolution().

◆ cumulateScan2()

void pappso::TimsFrame::cumulateScan2 ( std::size_t  scanNum,
std::map< quint32, quint32 > &  accumulate_into,
quint32  accepted_tof_index_range_begin,
quint32  accepted_tof_index_range_end 
) const
protectedvirtual

Reimplemented in pappso::TimsFrameType1.

Definition at line 344 of file timsframe.cpp.

348{
349 // qDebug();
350
351 if(m_timsDataFrame.size() == 0)
352 return;
353
354 // checkScanNum(scanNum);
355
356 std::size_t scan_size = getNbrPeaks(scanNum);
357 std::size_t scan_offset = getScanOffset(scanNum);
358 qint32 previous = -1;
359
360 for(std::size_t i = 0; i < scan_size; i++)
361 {
362 quint32 x = (*(quint32 *)((m_timsDataFrame.constData() +
363 (scan_offset * 4) + (i * 8))) +
364 previous);
365
366 if(x < accepted_tof_index_range_begin)
367 {
368 // qDebug() << "TOF index still not in range, x:" << x;
369 continue;
370 }
371 if(x > accepted_tof_index_range_end)
372 {
373 // qDebug() << "TOF index already out of range, x:" << x;
374 break;
375 }
376
377 // qDebug() << "TOF index in range, x:" << x;
378
379 quint32 y = (*(quint32 *)(m_timsDataFrame.constData() +
380 (scan_offset * 4) + (i * 8) + 4));
381
382 previous = x;
383
384 auto ret = accumulate_into.insert(std::pair<quint32, quint32>(x, y));
385
386 if(ret.second == false)
387 {
388 // already existed : cumulate
389 ret.first->second += y;
390 }
391 }
392
393 // qDebug();
394}

References getNbrPeaks(), getScanOffset(), m_timsDataFrame, pappso::x, and pappso::y.

Referenced by cumulateScansToTraceMzDownResolution2().

◆ cumulateScansInRawMap()

void pappso::TimsFrame::cumulateScansInRawMap ( std::map< quint32, quint32 > &  rawSpectrum,
std::size_t  scanNumBegin,
std::size_t  scanNumEnd 
) const
overridevirtual

cumulate scan list into a trace into a raw spectrum map

Parameters
rawSpectrumsimple map of integers to cumulate raw counts
scanNumBeginfirst scan to cumulate
scanNumEndlast scan to cumulate

Reimplemented from pappso::TimsFrameBase.

Definition at line 671 of file timsframe.cpp.

674{
675 // qDebug() << "begin mobility_scan_begin=" << mobility_scan_begin
676 //<< " mobility_scan_end=" << mobility_scan_end;
677
678 if(m_timsDataFrame.size() == 0)
679 return;
680 try
681 {
682
683 std::size_t mobility_scan_max = mobility_scan_end + 1;
684 qDebug();
685 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
686 {
687 qDebug() << i;
688 cumulateScan(i, rawSpectrum);
689 qDebug() << i;
690 // local_accumulationTime += m_accumulationTime;
691 }
692 }
693
694 catch(std::exception &error)
695 {
696 qDebug() << QString("Failure in %1 %2 to %3 :\n %4")
697 .arg(__FUNCTION__)
698 .arg(mobility_scan_begin)
699 .arg(mobility_scan_end)
700 .arg(error.what());
701 }
702
703 // qDebug() << "end";
704}
virtual void cumulateScan(std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into) const
cumulate a scan into a map

References cumulateScan(), and m_timsDataFrame.

◆ cumulateScansIntensities()

quint64 pappso::TimsFrame::cumulateScansIntensities ( std::size_t  mobility_scan_begin,
std::size_t  mobility_scan_end 
) const
overridevirtual

...

Parameters
mobility_scan_beginp_mobility_scan_begin:...
mobility_scan_endp_mobility_scan_end:...
Returns
quint64

Reimplemented from pappso::TimsFrameBase.

Definition at line 267 of file timsframe.cpp.

269{
270 quint64 summed_intensities = 0;
271
272 // qDebug() << "begin mobility_scan_begin =" << mobility_scan_begin
273 //<< "mobility_scan_end =" << mobility_scan_end;
274
275 if(m_timsDataFrame.size() == 0)
276 return summed_intensities;
277
278 try
279 {
280 std::size_t mobility_scan_max = mobility_scan_end + 1;
281
282 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
283 {
284 qDebug() << i;
285 summed_intensities += cumulateSingleScanIntensities(i);
286 qDebug() << i;
287 }
288 }
289 catch(std::exception &error)
290 {
291 qDebug() << QString("Failure in %1 %2 to %3 :\n %4")
292 .arg(__FUNCTION__)
293 .arg(mobility_scan_begin)
294 .arg(mobility_scan_end)
295 .arg(error.what());
296 }
297
298 // qDebug() << "end";
299
300 return summed_intensities;
301}
virtual quint64 cumulateSingleScanIntensities(std::size_t scanNum) const override

References cumulateSingleScanIntensities(), and m_timsDataFrame.

◆ cumulateScansToTrace()

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

cumulate scan list into a trace

Parameters
scanNumBeginfirst scan to cumulate
scanNumEndlast scan to cumulate
Returns
Trace mz and intensity values

Reimplemented from pappso::TimsFrameBase.

Definition at line 398 of file timsframe.cpp.

400{
401 // qDebug();
402
403 Trace new_trace;
404
405 try
406 {
407 if(m_timsDataFrame.size() == 0)
408 return new_trace;
409 std::map<quint32, quint32> raw_spectrum;
410 // double local_accumulationTime = 0;
411
412 std::size_t mobility_scan_max = mobility_scan_end + 1;
413 qDebug();
414 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
415 {
416 // qDebug() << i;
417 cumulateScan(i, raw_spectrum);
418 // qDebug() << i;
419
420 // local_accumulationTime += m_accumulationTime;
421 }
422
423 // qDebug();
424
425 pappso::DataPoint data_point_cumul;
426
427
428 MzCalibrationInterface *mz_calibration_p =
430
431
432 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
433 {
434 data_point_cumul.x =
435 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
436 // normalization
437 data_point_cumul.y =
438 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
439 new_trace.push_back(data_point_cumul);
440 }
441 new_trace.sortX();
442
443 // qDebug();
444 }
445
446 catch(std::exception &error)
447 {
448 qDebug() << QString(
449 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
450 .arg(mobility_scan_begin, mobility_scan_end)
451 .arg(error.what());
452 }
453 return new_trace;
454}
double m_accumulationTime
accumulation time in milliseconds
virtual const MzCalibrationInterfaceSPtr & getMzCalibrationInterfaceSPtr() const final
get the MzCalibration model to compute mz and TOF for this frame
pappso_double x
Definition datapoint.h:23
pappso_double y
Definition datapoint.h:24

References cumulateScan(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsFrameBase::m_accumulationTime, m_timsDataFrame, pappso::Trace::sortX(), pappso::DataPoint::x, and pappso::DataPoint::y.

◆ cumulateScansToTraceMzDownResolution()

Trace pappso::TimsFrame::cumulateScansToTraceMzDownResolution ( std::size_t  mzindex_merge_window,
std::size_t  scanNumBegin,
std::size_t  scanNumEnd,
quint32 &  mz_minimum_index,
quint32 &  mz_maximum_index 
) const
overridevirtual

cumulate spectrum given a scan number range need the binary file The intensities are normalized with respect to the frame accumulation time to leverage computing performance, this function decreases the mz resolution

Parameters
mzindex_merge_windowwidth of the mzindex window used to merge all intensities into a single point. This results in faster computing.
scanNumBeginscan number in the frame in the order it lies in binary file, from 0 to N-1
scanNumEndscan number in the frame in the order it lies in binary file, from 0 to N-1
mz_minimum_indexreport the minimum mz index contained in the resulting trace
mz_maximum_indexreport the maximum mz index contained in the resulting trace

Reimplemented from pappso::TimsFrameBase.

Definition at line 457 of file timsframe.cpp.

463{
464 // qDebug();
465
466 Trace new_trace;
467
468 try
469 {
470 if(m_timsDataFrame.size() == 0)
471 {
472 qDebug() << "The frame is empty, returning empty trace.";
473 return new_trace;
474 }
475
476 // Allocate a map for (TOF,intensity) pairs to
477 // accumulate ion mobility scans.
478
479 std::map<quint32, quint32> raw_spectrum;
480 // double local_accumulationTime = 0;
481
482 std::size_t mobility_scan_max = mobility_scan_end + 1;
483
484 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
485 {
486 // qDebug() << "Going to cumulate currently iterated mobility scan:"
487 // << i;
488 cumulateScan(i, raw_spectrum);
489 // qDebug() << "Done cumulating currently iterated mobility scan:" <<
490 // i;
491
492 // local_accumulationTime += m_accumulationTime;
493 }
494
495 // qDebug();
496
497 pappso::DataPoint data_point_cumul;
498
499 MzCalibrationInterface *mz_calibration_p =
501
502 // If the caller asks that m/z values be binned larger than they are,
503 // ask that the m/z raw map be reduced in resolution.
504 if(mz_index_merge_window > 0)
505 raw_spectrum = downsizeMzRawMap(mz_index_merge_window, raw_spectrum);
506
507 // Store the first mz index and the last mz index of the current spectrum.
508 // The values are set to the out parameters.
509 mz_minimum_index_out = std::numeric_limits<quint32>::max();
510 mz_maximum_index_out = 0;
511
512 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
513 {
514 if(pair_tof_intensity.first > mz_maximum_index_out)
515 mz_maximum_index_out = pair_tof_intensity.first;
516 if(pair_tof_intensity.first < mz_minimum_index_out)
517 mz_minimum_index_out = pair_tof_intensity.first;
518
519 // Convert the TOF index to m/z
520 data_point_cumul.x =
521 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
522
523 // Normalization
524 data_point_cumul.y =
525 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
526
527 // Finally make the data point a new Trace point.
528 new_trace.push_back(data_point_cumul);
529 }
530
531 // qDebug() << "At this point we have mz_minimum_index_out:"
532 // << mz_minimum_index_out
533 // << "and mz_maximum_index_out:" << mz_maximum_index_out;
534
535 // FIXME: this does not seem to be necessary since raw_spectrum is a map
536 // with auto-sorting on the keys which are quint32.
537 // new_trace.sortX();
538
539 // qDebug();
540 }
541 catch(std::exception &error)
542 {
543 qDebug() << QString(
544 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
545 .arg(mobility_scan_begin, mobility_scan_end)
546 .arg(error.what());
547 }
548
549 // qDebug() << "Returning new trace of size:" << new_trace.size();
550
551 return new_trace;
552}
virtual std::map< quint32, quint32 > & downsizeMzRawMap(std::size_t mzindex_merge_window, std::map< quint32, quint32 > &rawSpectrum) const
downsize mz resolution to lower the number of real mz computations

References cumulateScan(), pappso::TimsFrameBase::downsizeMzRawMap(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsFrameBase::m_accumulationTime, m_timsDataFrame, pappso::DataPoint::x, and pappso::DataPoint::y.

◆ cumulateScansToTraceMzDownResolution2()

Trace pappso::TimsFrame::cumulateScansToTraceMzDownResolution2 ( std::size_t  mz_index_merge_window,
double  mz_range_begin,
double  mz_range_end,
std::size_t  mobility_scan_begin,
std::size_t  mobility_scan_end,
quint32 &  mz_minimum_index_out,
quint32 &  mz_maximum_index_out 
) const
overridevirtual

cumulate spectrum given a scan number range need the binary file The intensities are normalized with respect to the frame accumulation time to leverage computing performance, this function decreases the mz resolution

Parameters
mzindex_merge_windowwidth of the mzindex window used to merge all intensities into a single point. This results in faster computing.
mz_range_begin
mz_range_end
scanNumBeginscan number in the frame in the order it lies in binary file, from 0 to N-1
scanNumEndscan number in the frame in the order it lies in binary file, from 0 to N-1
mz_minimum_indexreport the minimum mz index contained in the resulting trace (constrained by the mz_range_begin)
mz_maximum_indexreport the maximum mz index contained in the resulting trace (constrained by the mz_range_end)

Reimplemented from pappso::TimsFrameBase.

Definition at line 556 of file timsframe.cpp.

564{
565 // qDebug();
566
567 Trace new_trace;
568
569 try
570 {
571 if(m_timsDataFrame.size() == 0)
572 {
573 qDebug() << "The frame is empty, returning empty trace.";
574 return new_trace;
575 }
576
577 // Allocate a map for (TOF index,intensity) pairs to
578 // accumulate ion mobility scans.
579
580 std::map<quint32, quint32> raw_spectrum;
581 // double local_accumulationTime = 0;
582
583 std::size_t mobility_scan_max = mobility_scan_end + 1;
584
585 quint32 only_in_mz_begin_tof_index_range =
586 getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(
587 mz_range_begin);
588 quint32 only_in_mz_end_tof_index_range =
589 getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(mz_range_end);
590
591 // qDebug() << "20231129 TOF index range begin:"
592 // << only_in_mz_begin_tof_index_range;
593 // qDebug() << "20231129 TOF index range end:"
594 // << only_in_mz_end_tof_index_range;
595
596 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
597 {
598 // qDebug() << "Going to cumulate currently iterated mobility scan:"
599 // << i;
601 raw_spectrum,
602 only_in_mz_begin_tof_index_range,
603 only_in_mz_end_tof_index_range);
604 // qDebug() << "Done cumulating currently iterated mobility scan:" <<
605 // i;
606
607 // local_accumulationTime += m_accumulationTime;
608 }
609
610 // qDebug();
611
612 pappso::DataPoint data_point_cumul;
613
614 MzCalibrationInterface *mz_calibration_p =
616
617 // If the caller asks that m/z values be binned larger than they are,
618 // ask that the m/z raw map be reduced in resolution.
619 if(mz_index_merge_window > 0)
620 raw_spectrum = downsizeMzRawMap(mz_index_merge_window, raw_spectrum);
621
622 // Store the first mz index and the last mz index of the current spectrum.
623 // The values are set to the out parameters.
624 mz_minimum_index_out = std::numeric_limits<quint32>::max();
625 mz_maximum_index_out = 0;
626
627 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
628 {
629 if(pair_tof_intensity.first > mz_maximum_index_out)
630 mz_maximum_index_out = pair_tof_intensity.first;
631 if(pair_tof_intensity.first < mz_minimum_index_out)
632 mz_minimum_index_out = pair_tof_intensity.first;
633
634 // Convert the TOF index to m/z
635 data_point_cumul.x =
636 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
637
638 // Normalization
639 data_point_cumul.y =
640 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
641
642 // Finally make the data point a new Trace point.
643 new_trace.push_back(data_point_cumul);
644 }
645
646 // qDebug() << "At this point we have mz_minimum_index_out:"
647 // << mz_minimum_index_out
648 // << "and mz_maximum_index_out:" << mz_maximum_index_out;
649
650 // FIXME: this does not seem to be necessary since raw_spectrum is a map
651 // with auto-sorting on the keys which are quint32.
652 // new_trace.sortX();
653
654 // qDebug();
655 }
656 catch(std::exception &error)
657 {
658 qDebug() << QString(
659 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
660 .arg(mobility_scan_begin, mobility_scan_end)
661 .arg(error.what());
662 }
663
664 // qDebug() << "Returning new trace of size:" << new_trace.size();
665
666 return new_trace;
667}
virtual void cumulateScan2(std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const

References cumulateScan2(), pappso::TimsFrameBase::downsizeMzRawMap(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsFrameBase::m_accumulationTime, m_timsDataFrame, pappso::DataPoint::x, and pappso::DataPoint::y.

◆ cumulateSingleScanIntensities()

quint64 pappso::TimsFrame::cumulateSingleScanIntensities ( std::size_t  scanNum) const
overridevirtual

Reimplemented from pappso::TimsFrameBase.

Definition at line 220 of file timsframe.cpp.

221{
222 qDebug();
223
224 quint64 summed_intensities = 0;
225
226 if(m_timsDataFrame.size() == 0)
227 return summed_intensities;
228 // checkScanNum(scanNum);
229
230 std::size_t size = getNbrPeaks(scanNum);
231
232 std::size_t offset = getScanOffset(scanNum);
233
234 qint32 previous = -1;
235
236 for(std::size_t i = 0; i < size; i++)
237 {
238 quint32 x =
239 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
240 previous);
241
242 quint32 y = (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) +
243 (i * 8) + 4));
244
245 previous = x;
246
247 summed_intensities += y;
248 }
249
250 // Normalization over the accumulation time for this frame.
251 summed_intensities *= ((double)100.0 / m_accumulationTime);
252
253 qDebug();
254
255 return summed_intensities;
256}

References getNbrPeaks(), getScanOffset(), pappso::TimsFrameBase::m_accumulationTime, m_timsDataFrame, pappso::x, and pappso::y.

Referenced by cumulateScansIntensities().

◆ extractTimsXicListInRtRange()

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

Definition at line 819 of file timsframe.cpp.

823{
824 qDebug() << std::distance(itXicListbegin, itXicListend);
825
826 std::vector<TimsFrame::XicComputeStructure> tmp_xic_list;
827
828 for(auto it = itXicListbegin; it != itXicListend; it++)
829 {
830 tmp_xic_list.push_back(TimsFrame::XicComputeStructure(this, **it));
831
832 qDebug() << " tmp_xic_struct.mobilityIndexBegin="
833 << tmp_xic_list.back().mobilityIndexBegin
834 << " tmp_xic_struct.mobilityIndexEnd="
835 << tmp_xic_list.back().mobilityIndexEnd;
836
837 qDebug() << " tmp_xic_struct.mzIndexLowerBound="
838 << tmp_xic_list.back().mzIndexLowerBound
839 << " tmp_xic_struct.mzIndexUpperBound="
840 << tmp_xic_list.back().mzIndexUpperBound;
841 }
842 if(tmp_xic_list.size() == 0)
843 return;
844 /*
845 std::sort(tmp_xic_list.begin(), tmp_xic_list.end(), [](const
846 TimsXicStructure &a, const TimsXicStructure &b) { return
847 a.mobilityIndexBegin < b.mobilityIndexBegin;
848 });
849 */
850 std::vector<std::size_t> unique_scan_num_list;
851 for(auto &&struct_xic : tmp_xic_list)
852 {
853 for(std::size_t scan = struct_xic.mobilityIndexBegin;
854 (scan <= struct_xic.mobilityIndexEnd) && (scan < m_scanNumber);
855 scan++)
856 {
857 unique_scan_num_list.push_back(scan);
858 }
859 }
860 std::sort(unique_scan_num_list.begin(), unique_scan_num_list.end());
861 auto it_scan_num_end =
862 std::unique(unique_scan_num_list.begin(), unique_scan_num_list.end());
863 auto it_scan_num = unique_scan_num_list.begin();
864
865 while(it_scan_num != it_scan_num_end)
866 {
867 TraceSPtr ms_spectrum = getRawTraceSPtr(*it_scan_num);
868 // qDebug() << ms_spectrum.get()->toString();
869 for(auto &&tmp_xic_struct : tmp_xic_list)
870 {
871 if(((*it_scan_num) >= tmp_xic_struct.mobilityIndexBegin) &&
872 ((*it_scan_num) <= tmp_xic_struct.mobilityIndexEnd))
873 {
874 if(method == XicExtractMethod::max)
875 {
876 tmp_xic_struct.tmpIntensity +=
877 ms_spectrum.get()->maxY(tmp_xic_struct.mzIndexLowerBound,
878 tmp_xic_struct.mzIndexUpperBound);
879
880 qDebug() << "tmp_xic_struct.tmpIntensity="
881 << tmp_xic_struct.tmpIntensity;
882 }
883 else
884 {
885 // sum
886 tmp_xic_struct.tmpIntensity +=
887 ms_spectrum.get()->sumY(tmp_xic_struct.mzIndexLowerBound,
888 tmp_xic_struct.mzIndexUpperBound);
889 qDebug() << "tmp_xic_struct.tmpIntensity="
890 << tmp_xic_struct.tmpIntensity;
891 }
892 }
893 }
894 it_scan_num++;
895 }
896
897 for(auto &&tmp_xic_struct : tmp_xic_list)
898 {
899 if(tmp_xic_struct.tmpIntensity != 0)
900 {
901 qDebug() << tmp_xic_struct.xic_ptr;
902 tmp_xic_struct.xic_ptr->push_back(
903 {m_time, tmp_xic_struct.tmpIntensity});
904 }
905 }
906
907 qDebug();
908}
double m_time
retention time
virtual pappso::TraceSPtr getRawTraceSPtr(std::size_t scanNum) const
get the raw index tof_index and intensities (normalized)
std::shared_ptr< Trace > TraceSPtr
Definition trace.h:135
@ max
maximum of intensities

References getRawTraceSPtr(), pappso::TimsFrameBase::m_scanNumber, pappso::TimsFrameBase::m_time, and pappso::max.

◆ getMassSpectrumSPtr()

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

get Mass spectrum with peaks for this scan number need the binary file

Parameters
scanNumscan number in the frame in the order it lies in binary file, from 0 to N-1 (this is the mobility index)

Reimplemented from pappso::TimsFrameBase.

Reimplemented in pappso::TimsFrameType1.

Definition at line 708 of file timsframe.cpp.

709{
710
711 // qDebug() << " scanNum=" << scanNum;
712
713 checkScanNum(scanNum);
714
715 // qDebug();
716
717 pappso::MassSpectrumSPtr mass_spectrum_sptr =
718 std::make_shared<pappso::MassSpectrum>();
719 // std::vector<DataPoint>
720
721 if(m_timsDataFrame.size() == 0)
722 return mass_spectrum_sptr;
723
724 // qDebug();
725
726 std::size_t size = getNbrPeaks(scanNum);
727
728 std::size_t offset = getScanOffset(scanNum);
729
730 MzCalibrationInterface *mz_calibration_p =
732
733
734 qint32 previous = -1;
735 qint32 tof_index;
736 // std::vector<quint32> index_list;
737 DataPoint data_point;
738 for(std::size_t i = 0; i < size; i++)
739 {
740 tof_index =
741 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
742 previous);
743 data_point.y = (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) +
744 (i * 8) + 4));
745
746 // intensity normalization
747 data_point.y *= 100.0 / m_accumulationTime;
748
749 previous = tof_index;
750
751
752 // mz calibration
753 data_point.x = mz_calibration_p->getMzFromTofIndex(tof_index);
754 mass_spectrum_sptr.get()->push_back(data_point);
755 }
756
757 // qDebug();
758
759 return mass_spectrum_sptr;
760}
bool checkScanNum(std::size_t scanNum) const
check that this scan number exists
std::shared_ptr< MassSpectrum > MassSpectrumSPtr

References pappso::TimsFrameBase::checkScanNum(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), getNbrPeaks(), getScanOffset(), pappso::TimsFrameBase::m_accumulationTime, m_timsDataFrame, pappso::DataPoint::x, and pappso::DataPoint::y.

◆ getMobilityScan()

Trace pappso::TimsFrame::getMobilityScan ( std::size_t  scanNum,
std::size_t  mz_index_merge_window,
double  mz_range_begin,
double  mz_range_end,
quint32 &  mz_minimum_index_out,
quint32 &  mz_maximum_index_out 
) const
overridevirtual

get a single mobility scan m/z + intensities

Parameters
scanNumscan number in the frame in the order it lies in binary file, from 0 to N-1
mzindex_merge_windowwidth of the mzindex window used to merge all intensities into a single point. This results in faster computing.
mz_range_begin
mz_range_end
mz_minimum_indexreport the minimum mz index contained in the resulting trace (constrained by the mz_range_begin)
mz_maximum_indexreport the maximum mz index contained in the resulting trace (constrained by the mz_range_end)

Reimplemented from pappso::TimsFrameBase.

Definition at line 764 of file timsframe.cpp.

770{
771 // qDebug();
772 qDebug() << "mz_index_merge_window=" << mz_index_merge_window;
773 Trace spectrum;
774 quint32 mz_index_begin = 0;
775 quint32 mz_index_end = std::numeric_limits<quint32>::max();
776 if(mz_range_end > 0)
777 {
778 // qDebug();
779 mz_index_begin =
780 msp_mzCalibration.get()->getTofIndexFromMz(mz_range_begin);
781 mz_index_end = msp_mzCalibration.get()->getTofIndexFromMz(mz_range_end);
782 }
783 auto raw_spectrum =
784 getRawValuePairList(scanNum, mz_index_begin, mz_index_end);
785 qDebug() << "mz_index_begin=" << mz_index_begin
786 << " mz_index_end=" << mz_index_end;
787 qDebug() << "mz_index_merge_window=" << mz_index_merge_window
788 << " raw_spectrum.size()=" << raw_spectrum.size();
789
790 if(mz_index_merge_window > 0)
791 {
792 qDebug() << "mz_index_merge_window=" << mz_index_merge_window
793 << " raw_spectrum.size()=" << raw_spectrum.size();
794 raw_spectrum =
795 downsizeMzRawValuePairList(mz_index_merge_window, raw_spectrum);
796 }
797
798 if(raw_spectrum.size() > 0)
799 {
800 mz_minimum_index_out = raw_spectrum.front().mz_tof_index;
801 mz_maximum_index_out = raw_spectrum.back().mz_tof_index;
802
803 // qDebug();
804 for(auto &&element : raw_spectrum)
805 {
806 spectrum.push_back(
807 {msp_mzCalibration.get()->getMzFromTofIndex(element.mz_tof_index),
808 (double)element.intensity_index});
809
810 // intensity normalization
811 spectrum.back().y *= 100.0 / m_accumulationTime;
812 }
813 }
814 // qDebug();
815 return spectrum;
816}
virtual std::vector< RawValuePair > & downsizeMzRawValuePairList(std::size_t mzindex_merge_window, std::vector< RawValuePair > &spectrum) const
downsize mz resolution to lower the number of real mz computations
MzCalibrationInterfaceSPtr msp_mzCalibration
virtual std::vector< RawValuePair > getRawValuePairList(std::size_t scanNum, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const
get the raw index tof_index and intensities (normalized)

References pappso::TimsFrameBase::downsizeMzRawValuePairList(), getRawValuePairList(), pappso::TimsFrameBase::m_accumulationTime, and pappso::TimsFrameBase::msp_mzCalibration.

◆ getNbrPeaks()

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

get the number of peaks in this spectrum need the binary file

Parameters
scanNumscan number in the frame in the order it lies in binary file, from 0 to N-1

Reimplemented from pappso::TimsFrameBase.

Reimplemented in pappso::TimsFrameType1.

Definition at line 129 of file timsframe.cpp.

130{
131 if(m_timsDataFrame.size() == 0)
132 return 0;
133 /*
134 if(scanNum == 0)
135 {
136 quint32 res = (*(quint32 *)(m_timsDataFrame.constData() + 4)) -
137 (*(quint32 *)(m_timsDataFrame.constData()-4));
138 return res / 2;
139 }*/
140 if(scanNum == (m_scanNumber - 1))
141 {
142 auto nb_uint4 = m_timsDataFrame.size() / 4;
143
144 std::size_t cumul = 0;
145 for(quint32 i = 0; i < m_scanNumber; i++)
146 {
147 cumul += (*(quint32 *)(m_timsDataFrame.constData() + (i * 4)));
148 }
149 return (nb_uint4 - cumul) / 2;
150 }
151 checkScanNum(scanNum);
152
153 // quint32 *res = (quint32 *)(m_timsDataFrame.constData() + (scanNum * 4));
154 // qDebug() << " res=" << *res;
155 return (*(quint32 *)(m_timsDataFrame.constData() + ((scanNum + 1) * 4))) / 2;
156}

References pappso::TimsFrameBase::checkScanNum(), pappso::TimsFrameBase::m_scanNumber, and m_timsDataFrame.

Referenced by cumulateScan(), cumulateScan2(), cumulateSingleScanIntensities(), getMassSpectrumSPtr(), getRawTraceSPtr(), getRawValuePairList(), getScanIndexList(), and getScanIntensities().

◆ getRawTraceSPtr()

pappso::TraceSPtr pappso::TimsFrame::getRawTraceSPtr ( std::size_t  scanNum) const
protectedvirtual

get the raw index tof_index and intensities (normalized)

Parameters
scanNumthe scan number to extract
Returns
trace vector

Reimplemented in pappso::TimsFrameType1.

Definition at line 912 of file timsframe.cpp.

913{
914
915 // qDebug();
916
917 pappso::TraceSPtr trace_sptr = std::make_shared<pappso::Trace>();
918 // std::vector<DataPoint>
919
920 if(m_timsDataFrame.size() == 0)
921 return trace_sptr;
922 // qDebug();
923
924 std::size_t size = getNbrPeaks(scanNum);
925
926 std::size_t offset = getScanOffset(scanNum);
927
928 qint32 previous = -1;
929 std::vector<quint32> index_list;
930 for(std::size_t i = 0; i < size; i++)
931 {
932 DataPoint data_point(
933 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
934 previous),
935 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
936 4)));
937
938 // intensity normalization
939 data_point.y *= 100.0 / m_accumulationTime;
940
941 previous = data_point.x;
942 trace_sptr.get()->push_back(data_point);
943 }
944 // qDebug();
945 return trace_sptr;
946}

References getNbrPeaks(), getScanOffset(), pappso::TimsFrameBase::m_accumulationTime, m_timsDataFrame, pappso::DataPoint::x, and pappso::DataPoint::y.

Referenced by extractTimsXicListInRtRange().

◆ getRawValuePairList()

std::vector< TimsFrame::RawValuePair > pappso::TimsFrame::getRawValuePairList ( std::size_t  scanNum,
quint32  accepted_tof_index_range_begin,
quint32  accepted_tof_index_range_end 
) const
protectedvirtual

get the raw index tof_index and intensities (normalized)

Parameters
scanNumthe scan number to extract
accepted_tof_index_range_beginmz index begin
accepted_tof_index_range_endmz index end
Returns
vector of RawValuePair

Reimplemented in pappso::TimsFrameType1.

Definition at line 950 of file timsframe.cpp.

953{
954 // qDebug();
955
956 std::vector<TimsFrame::RawValuePair> trace_sptr;
957 // std::vector<DataPoint>
958
959 if(m_timsDataFrame.size() == 0)
960 return trace_sptr;
961 // qDebug();
962
963 std::size_t size = getNbrPeaks(scanNum);
964
965 std::size_t offset = getScanOffset(scanNum);
966
967 // qDebug() << size;
968 qint32 previous = -1;
969 std::vector<quint32> index_list;
970 for(std::size_t i = 0; i < size; i++)
971 {
972
973 // qDebug() << i;
974 TimsFrame::RawValuePair data_point(
975 {(*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
976 previous),
977 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
978 4))});
979 if(data_point.mz_tof_index < accepted_tof_index_range_begin)
980 {
981 // qDebug() << "TOF index still not in range, x:" << x;
982 continue;
983 }
984 if(data_point.mz_tof_index > accepted_tof_index_range_end)
985 {
986 // qDebug() << "TOF index already out of range, x:" << x;
987 break;
988 }
989
990
991 previous = data_point.mz_tof_index;
992 trace_sptr.push_back(data_point);
993 }
994 qDebug() << trace_sptr.size();
995 return trace_sptr;
996}

References getNbrPeaks(), getScanOffset(), m_timsDataFrame, and pappso::TimsFrameBase::RawValuePair::mz_tof_index.

Referenced by getMobilityScan().

◆ getScanIndexList()

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

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

Reimplemented from pappso::TimsFrameBase.

Reimplemented in pappso::TimsFrameType1.

Definition at line 171 of file timsframe.cpp.

172{
173 qDebug();
174 checkScanNum(scanNum);
175 std::vector<quint32> scan_tof;
176
177 if(m_timsDataFrame.size() == 0)
178 return scan_tof;
179 scan_tof.resize(getNbrPeaks(scanNum));
180
181 std::size_t offset = getScanOffset(scanNum);
182
183 qint32 previous = -1;
184 for(std::size_t i = 0; i < scan_tof.size(); i++)
185 {
186 scan_tof[i] =
187 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
188 previous;
189 previous = scan_tof[i];
190 }
191 qDebug();
192 return scan_tof;
193}

References pappso::TimsFrameBase::checkScanNum(), getNbrPeaks(), getScanOffset(), and m_timsDataFrame.

Referenced by pappso::BaseColorMapPlotWidget::addColorMap().

◆ getScanIntensities()

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

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

Reimplemented from pappso::TimsFrameBase.

Reimplemented in pappso::TimsFrameType1.

Definition at line 196 of file timsframe.cpp.

197{
198 qDebug();
199 checkScanNum(scanNum);
200 std::vector<quint32> scan_intensities;
201
202 if(m_timsDataFrame.size() == 0)
203 return scan_intensities;
204
205 scan_intensities.resize(getNbrPeaks(scanNum));
206
207 std::size_t offset = getScanOffset(scanNum);
208
209 for(std::size_t i = 0; i < scan_intensities.size(); i++)
210 {
211 scan_intensities[i] = (*(quint32 *)(m_timsDataFrame.constData() +
212 (offset * 4) + (i * 8) + 4));
213 }
214 qDebug();
215 return scan_intensities;
216}

References pappso::TimsFrameBase::checkScanNum(), getNbrPeaks(), getScanOffset(), and m_timsDataFrame.

Referenced by pappso::BaseColorMapPlotWidget::addColorMap().

◆ getScanOffset()

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

get offset for this spectrum in the binary file

Parameters
scanNumscan number in the frame in the order it lies in binary file, from 0 to N-1

Definition at line 159 of file timsframe.cpp.

160{
161 std::size_t offset = 0;
162 for(std::size_t i = 0; i < (scanNum + 1); i++)
163 {
164 offset += (*(quint32 *)(m_timsDataFrame.constData() + (i * 4)));
165 }
166 return offset;
167}

References m_timsDataFrame.

Referenced by cumulateScan(), cumulateScan2(), cumulateSingleScanIntensities(), getMassSpectrumSPtr(), getRawTraceSPtr(), getRawValuePairList(), getScanIndexList(), and getScanIntensities().

◆ unshufflePacket()

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

unshuffle data packet of tims compression type 2

Parameters
srcis a zstd decompressed buffer pointer

Definition at line 102 of file timsframe.cpp.

103{
104 qDebug();
105 quint64 len = m_timsDataFrame.size();
106 if(len % 4 != 0)
107 {
109 QObject::tr("TimsFrame::unshufflePacket error: len % 4 != 0"));
110 }
111
112 quint64 nb_uint4 = len / 4;
113
114 char *dest = m_timsDataFrame.data();
115 quint64 src_offset = 0;
116
117 for(quint64 j = 0; j < 4; j++)
118 {
119 for(quint64 i = 0; i < nb_uint4; i++)
120 {
121 dest[(i * 4) + j] = src[src_offset];
122 src_offset++;
123 }
124 }
125 qDebug();
126}

References m_timsDataFrame.

Referenced by TimsFrame().

Member Data Documentation

◆ m_timsDataFrame

◆ TimsDirectXicExtractor

friend pappso::TimsFrame::TimsDirectXicExtractor
private

Definition at line 53 of file timsframe.h.


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