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 cumulateScanToTrace (std::size_t scanNumBegin, std::size_t scanNumEnd) const override
 cumulate scan list into a trace
 
virtual Trace cumulateScanToTraceMzDownResolution (std::size_t mzindex_merge_window, std::size_t scanNumBegin, std::size_t scanNumEnd, quint32 &minimum_index, quint32 &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
 
Trace cumulateScanToTraceMzDownResolution2 (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
 
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 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::MassSpectrumCstSPtr getMassSpectrumCstSPtr (std::size_t scanNum) const
 get the mass spectrum corresponding to a scan number
 
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
 
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
 
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, double mz_range_begin, double mz_range_end) const
 
virtual pappso::TraceSPtr getRawTraceSPtr (std::size_t scanNum) const
 get the raw index tof_index and intensities (normalized)
 

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:223
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(), cumulateScanToTrace(), and cumulateScanToTraceMzDownResolution().

◆ cumulateScan2()

void pappso::TimsFrame::cumulateScan2 ( std::size_t  scanNum,
std::map< quint32, quint32 > &  accumulate_into,
double  mz_range_begin,
double  mz_range_end 
) const
protectedvirtual

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
358 std::size_t scan_offset = getScanOffset(scanNum);
359
360 qint32 previous = -1;
361
362 for(std::size_t i = 0; i < scan_size; i++)
363 {
364 quint32 x = (*(quint32 *)((m_timsDataFrame.constData() +
365 (scan_offset * 4) + (i * 8))) +
366 previous);
367
368 if(x < mz_range_begin)
369 continue;
370 if(x > mz_range_end)
371 break;
372
373 quint32 y = (*(quint32 *)(m_timsDataFrame.constData() +
374 (scan_offset * 4) + (i * 8) + 4));
375
376 previous = x;
377
378 auto ret = accumulate_into.insert(std::pair<quint32, quint32>(x, y));
379
380 if(ret.second == false)
381 {
382 // already existed : cumulate
383 ret.first->second += y;
384 }
385 }
386
387 // qDebug();
388}

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

Referenced by cumulateScanToTraceMzDownResolution2().

◆ 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 651 of file timsframe.cpp.

654{
655 // qDebug() << "begin mobility_scan_begin=" << mobility_scan_begin
656 //<< " mobility_scan_end=" << mobility_scan_end;
657
658 if(m_timsDataFrame.size() == 0)
659 return;
660 try
661 {
662
663 std::size_t mobility_scan_max = mobility_scan_end + 1;
664 qDebug();
665 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
666 {
667 qDebug() << i;
668 cumulateScan(i, rawSpectrum);
669 qDebug() << i;
670 // local_accumulationTime += m_accumulationTime;
671 }
672 }
673
674 catch(std::exception &error)
675 {
676 qDebug() << QString("Failure in %1 %2 to %3 :\n %4")
677 .arg(__FUNCTION__)
678 .arg(mobility_scan_begin)
679 .arg(mobility_scan_end)
680 .arg(error.what());
681 }
682
683 // qDebug() << "end";
684}
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.

◆ cumulateScanToTrace()

Trace pappso::TimsFrame::cumulateScanToTrace ( 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 392 of file timsframe.cpp.

394{
395 // qDebug();
396
397 Trace new_trace;
398
399 try
400 {
401 if(m_timsDataFrame.size() == 0)
402 return new_trace;
403 std::map<quint32, quint32> raw_spectrum;
404 // double local_accumulationTime = 0;
405
406 std::size_t mobility_scan_max = mobility_scan_end + 1;
407 qDebug();
408 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
409 {
410 // qDebug() << i;
411 cumulateScan(i, raw_spectrum);
412 // qDebug() << i;
413
414 // local_accumulationTime += m_accumulationTime;
415 }
416
417 // qDebug();
418
419 pappso::DataPoint data_point_cumul;
420
421
422 MzCalibrationInterface *mz_calibration_p =
424
425
426 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
427 {
428 data_point_cumul.x =
429 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
430 // normalization
431 data_point_cumul.y =
432 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
433 new_trace.push_back(data_point_cumul);
434 }
435 new_trace.sortX();
436
437 // qDebug();
438 }
439
440 catch(std::exception &error)
441 {
442 qDebug() << QString(
443 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
444 .arg(mobility_scan_begin, mobility_scan_end)
445 .arg(error.what());
446 }
447 return new_trace;
448}
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.

◆ cumulateScanToTraceMzDownResolution()

Trace pappso::TimsFrame::cumulateScanToTraceMzDownResolution ( std::size_t  mzindex_merge_window,
std::size_t  scanNumBegin,
std::size_t  scanNumEnd,
quint32 &  minimum_index,
quint32 &  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

Reimplemented from pappso::TimsFrameBase.

Definition at line 451 of file timsframe.cpp.

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

◆ cumulateScanToTraceMzDownResolution2()

Trace pappso::TimsFrame::cumulateScanToTraceMzDownResolution2 ( 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

Definition at line 550 of file timsframe.cpp.

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

756{
757 qDebug() << std::distance(itXicListbegin, itXicListend);
758
759 std::vector<TimsFrame::XicComputeStructure> tmp_xic_list;
760
761 for(auto it = itXicListbegin; it != itXicListend; it++)
762 {
763 tmp_xic_list.push_back(TimsFrame::XicComputeStructure(this, **it));
764
765 qDebug() << " tmp_xic_struct.mobilityIndexBegin="
766 << tmp_xic_list.back().mobilityIndexBegin
767 << " tmp_xic_struct.mobilityIndexEnd="
768 << tmp_xic_list.back().mobilityIndexEnd;
769
770 qDebug() << " tmp_xic_struct.mzIndexLowerBound="
771 << tmp_xic_list.back().mzIndexLowerBound
772 << " tmp_xic_struct.mzIndexUpperBound="
773 << tmp_xic_list.back().mzIndexUpperBound;
774 }
775 if(tmp_xic_list.size() == 0)
776 return;
777 /*
778 std::sort(tmp_xic_list.begin(), tmp_xic_list.end(), [](const
779 TimsXicStructure &a, const TimsXicStructure &b) { return
780 a.mobilityIndexBegin < b.mobilityIndexBegin;
781 });
782 */
783 std::vector<std::size_t> unique_scan_num_list;
784 for(auto &&struct_xic : tmp_xic_list)
785 {
786 for(std::size_t scan = struct_xic.mobilityIndexBegin;
787 (scan <= struct_xic.mobilityIndexEnd) && (scan < m_scanNumber);
788 scan++)
789 {
790 unique_scan_num_list.push_back(scan);
791 }
792 }
793 std::sort(unique_scan_num_list.begin(), unique_scan_num_list.end());
794 auto it_scan_num_end =
795 std::unique(unique_scan_num_list.begin(), unique_scan_num_list.end());
796 auto it_scan_num = unique_scan_num_list.begin();
797
798 while(it_scan_num != it_scan_num_end)
799 {
800 TraceSPtr ms_spectrum = getRawTraceSPtr(*it_scan_num);
801 // qDebug() << ms_spectrum.get()->toString();
802 for(auto &&tmp_xic_struct : tmp_xic_list)
803 {
804 if(((*it_scan_num) >= tmp_xic_struct.mobilityIndexBegin) &&
805 ((*it_scan_num) <= tmp_xic_struct.mobilityIndexEnd))
806 {
807 if(method == XicExtractMethod::max)
808 {
809 tmp_xic_struct.tmpIntensity +=
810 ms_spectrum.get()->maxY(tmp_xic_struct.mzIndexLowerBound,
811 tmp_xic_struct.mzIndexUpperBound);
812
813 qDebug() << "tmp_xic_struct.tmpIntensity="
814 << tmp_xic_struct.tmpIntensity;
815 }
816 else
817 {
818 // sum
819 tmp_xic_struct.tmpIntensity +=
820 ms_spectrum.get()->sumY(tmp_xic_struct.mzIndexLowerBound,
821 tmp_xic_struct.mzIndexUpperBound);
822 qDebug() << "tmp_xic_struct.tmpIntensity="
823 << tmp_xic_struct.tmpIntensity;
824 }
825 }
826 }
827 it_scan_num++;
828 }
829
830 for(auto &&tmp_xic_struct : tmp_xic_list)
831 {
832 if(tmp_xic_struct.tmpIntensity != 0)
833 {
834 qDebug() << tmp_xic_struct.xic_ptr;
835 tmp_xic_struct.xic_ptr->push_back(
836 {m_time, tmp_xic_struct.tmpIntensity});
837 }
838 }
839
840 qDebug();
841}
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.

◆ getMassSpectrumCstSPtr()

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

get the mass spectrum corresponding to a scan number

Parameters
scanNumthe scan number to retrieve

Definition at line 688 of file timsframe.cpp.

689{
690 // qDebug();
691
692 return getMassSpectrumSPtr(scanNum);
693}
virtual pappso::MassSpectrumSPtr getMassSpectrumSPtr(std::size_t scanNum) const override
get Mass spectrum with peaks for this scan number need the binary file

References getMassSpectrumSPtr().

◆ 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

Reimplemented from pappso::TimsFrameBase.

Reimplemented in pappso::TimsFrameType1.

Definition at line 696 of file timsframe.cpp.

697{
698
699 // qDebug() << " scanNum=" << scanNum;
700
701 checkScanNum(scanNum);
702
703 // qDebug();
704
705 pappso::MassSpectrumSPtr mass_spectrum_sptr =
706 std::make_shared<pappso::MassSpectrum>();
707 // std::vector<DataPoint>
708
709 if(m_timsDataFrame.size() == 0)
710 return mass_spectrum_sptr;
711
712 // qDebug();
713
714 std::size_t size = getNbrPeaks(scanNum);
715
716 std::size_t offset = getScanOffset(scanNum);
717
718 MzCalibrationInterface *mz_calibration_p =
720
721
722 qint32 previous = -1;
723 qint32 tof_index;
724 // std::vector<quint32> index_list;
725 DataPoint data_point;
726 for(std::size_t i = 0; i < size; i++)
727 {
728 tof_index =
729 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
730 previous);
731 data_point.y = (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) +
732 (i * 8) + 4));
733
734 // intensity normalization
735 data_point.y *= 100.0 / m_accumulationTime;
736
737 previous = tof_index;
738
739
740 // mz calibration
741 data_point.x = mz_calibration_p->getMzFromTofIndex(tof_index);
742 mass_spectrum_sptr.get()->push_back(data_point);
743 }
744
745 // qDebug();
746
747 return mass_spectrum_sptr;
748}
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.

Referenced by getMassSpectrumCstSPtr().

◆ 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(), 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 845 of file timsframe.cpp.

846{
847
848 // qDebug();
849
850 pappso::TraceSPtr trace_sptr = std::make_shared<pappso::Trace>();
851 // std::vector<DataPoint>
852
853 if(m_timsDataFrame.size() == 0)
854 return trace_sptr;
855 // qDebug();
856
857 std::size_t size = getNbrPeaks(scanNum);
858
859 std::size_t offset = getScanOffset(scanNum);
860
861 qint32 previous = -1;
862 std::vector<quint32> index_list;
863 for(std::size_t i = 0; i < size; i++)
864 {
865 DataPoint data_point(
866 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
867 previous),
868 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
869 4)));
870
871 // intensity normalization
872 data_point.y *= 100.0 / m_accumulationTime;
873
874 previous = data_point.x;
875 trace_sptr.get()->push_back(data_point);
876 }
877 // qDebug();
878 return trace_sptr;
879}

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

Referenced by extractTimsXicListInRtRange().

◆ 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(), 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: