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 &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 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
 
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, 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)
 

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:225
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,
double  mz_range_begin,
double  mz_range_end,
quint32  accepted_tof_index_range_begin,
quint32  accepted_tof_index_range_end 
) const
protectedvirtual

Definition at line 344 of file timsframe.cpp.

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

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

678{
679 // qDebug() << "begin mobility_scan_begin=" << mobility_scan_begin
680 //<< " mobility_scan_end=" << mobility_scan_end;
681
682 if(m_timsDataFrame.size() == 0)
683 return;
684 try
685 {
686
687 std::size_t mobility_scan_max = mobility_scan_end + 1;
688 qDebug();
689 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
690 {
691 qDebug() << i;
692 cumulateScan(i, rawSpectrum);
693 qDebug() << i;
694 // local_accumulationTime += m_accumulationTime;
695 }
696 }
697
698 catch(std::exception &error)
699 {
700 qDebug() << QString("Failure in %1 %2 to %3 :\n %4")
701 .arg(__FUNCTION__)
702 .arg(mobility_scan_begin)
703 .arg(mobility_scan_end)
704 .arg(error.what());
705 }
706
707 // qDebug() << "end";
708}
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 400 of file timsframe.cpp.

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

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

Definition at line 558 of file timsframe.cpp.

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

780{
781 qDebug() << std::distance(itXicListbegin, itXicListend);
782
783 std::vector<TimsFrame::XicComputeStructure> tmp_xic_list;
784
785 for(auto it = itXicListbegin; it != itXicListend; it++)
786 {
787 tmp_xic_list.push_back(TimsFrame::XicComputeStructure(this, **it));
788
789 qDebug() << " tmp_xic_struct.mobilityIndexBegin="
790 << tmp_xic_list.back().mobilityIndexBegin
791 << " tmp_xic_struct.mobilityIndexEnd="
792 << tmp_xic_list.back().mobilityIndexEnd;
793
794 qDebug() << " tmp_xic_struct.mzIndexLowerBound="
795 << tmp_xic_list.back().mzIndexLowerBound
796 << " tmp_xic_struct.mzIndexUpperBound="
797 << tmp_xic_list.back().mzIndexUpperBound;
798 }
799 if(tmp_xic_list.size() == 0)
800 return;
801 /*
802 std::sort(tmp_xic_list.begin(), tmp_xic_list.end(), [](const
803 TimsXicStructure &a, const TimsXicStructure &b) { return
804 a.mobilityIndexBegin < b.mobilityIndexBegin;
805 });
806 */
807 std::vector<std::size_t> unique_scan_num_list;
808 for(auto &&struct_xic : tmp_xic_list)
809 {
810 for(std::size_t scan = struct_xic.mobilityIndexBegin;
811 (scan <= struct_xic.mobilityIndexEnd) && (scan < m_scanNumber);
812 scan++)
813 {
814 unique_scan_num_list.push_back(scan);
815 }
816 }
817 std::sort(unique_scan_num_list.begin(), unique_scan_num_list.end());
818 auto it_scan_num_end =
819 std::unique(unique_scan_num_list.begin(), unique_scan_num_list.end());
820 auto it_scan_num = unique_scan_num_list.begin();
821
822 while(it_scan_num != it_scan_num_end)
823 {
824 TraceSPtr ms_spectrum = getRawTraceSPtr(*it_scan_num);
825 // qDebug() << ms_spectrum.get()->toString();
826 for(auto &&tmp_xic_struct : tmp_xic_list)
827 {
828 if(((*it_scan_num) >= tmp_xic_struct.mobilityIndexBegin) &&
829 ((*it_scan_num) <= tmp_xic_struct.mobilityIndexEnd))
830 {
831 if(method == XicExtractMethod::max)
832 {
833 tmp_xic_struct.tmpIntensity +=
834 ms_spectrum.get()->maxY(tmp_xic_struct.mzIndexLowerBound,
835 tmp_xic_struct.mzIndexUpperBound);
836
837 qDebug() << "tmp_xic_struct.tmpIntensity="
838 << tmp_xic_struct.tmpIntensity;
839 }
840 else
841 {
842 // sum
843 tmp_xic_struct.tmpIntensity +=
844 ms_spectrum.get()->sumY(tmp_xic_struct.mzIndexLowerBound,
845 tmp_xic_struct.mzIndexUpperBound);
846 qDebug() << "tmp_xic_struct.tmpIntensity="
847 << tmp_xic_struct.tmpIntensity;
848 }
849 }
850 }
851 it_scan_num++;
852 }
853
854 for(auto &&tmp_xic_struct : tmp_xic_list)
855 {
856 if(tmp_xic_struct.tmpIntensity != 0)
857 {
858 qDebug() << tmp_xic_struct.xic_ptr;
859 tmp_xic_struct.xic_ptr->push_back(
860 {m_time, tmp_xic_struct.tmpIntensity});
861 }
862 }
863
864 qDebug();
865}
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 712 of file timsframe.cpp.

713{
714 // qDebug();
715
716 return getMassSpectrumSPtr(scanNum);
717}
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 720 of file timsframe.cpp.

721{
722
723 // qDebug() << " scanNum=" << scanNum;
724
725 checkScanNum(scanNum);
726
727 // qDebug();
728
729 pappso::MassSpectrumSPtr mass_spectrum_sptr =
730 std::make_shared<pappso::MassSpectrum>();
731 // std::vector<DataPoint>
732
733 if(m_timsDataFrame.size() == 0)
734 return mass_spectrum_sptr;
735
736 // qDebug();
737
738 std::size_t size = getNbrPeaks(scanNum);
739
740 std::size_t offset = getScanOffset(scanNum);
741
742 MzCalibrationInterface *mz_calibration_p =
744
745
746 qint32 previous = -1;
747 qint32 tof_index;
748 // std::vector<quint32> index_list;
749 DataPoint data_point;
750 for(std::size_t i = 0; i < size; i++)
751 {
752 tof_index =
753 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
754 previous);
755 data_point.y = (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) +
756 (i * 8) + 4));
757
758 // intensity normalization
759 data_point.y *= 100.0 / m_accumulationTime;
760
761 previous = tof_index;
762
763
764 // mz calibration
765 data_point.x = mz_calibration_p->getMzFromTofIndex(tof_index);
766 mass_spectrum_sptr.get()->push_back(data_point);
767 }
768
769 // qDebug();
770
771 return mass_spectrum_sptr;
772}
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 869 of file timsframe.cpp.

870{
871
872 // qDebug();
873
874 pappso::TraceSPtr trace_sptr = std::make_shared<pappso::Trace>();
875 // std::vector<DataPoint>
876
877 if(m_timsDataFrame.size() == 0)
878 return trace_sptr;
879 // qDebug();
880
881 std::size_t size = getNbrPeaks(scanNum);
882
883 std::size_t offset = getScanOffset(scanNum);
884
885 qint32 previous = -1;
886 std::vector<quint32> index_list;
887 for(std::size_t i = 0; i < size; i++)
888 {
889 DataPoint data_point(
890 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
891 previous),
892 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
893 4)));
894
895 // intensity normalization
896 data_point.y *= 100.0 / m_accumulationTime;
897
898 previous = data_point.x;
899 trace_sptr.get()->push_back(data_point);
900 }
901 // qDebug();
902 return trace_sptr;
903}

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: