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 getScanPeakCount (std::size_t scanIndex) const override
 get the number of peaks in this spectrum need the binary file
 
virtual Trace cumulateScansToTrace (std::size_t scanIndexBegin, std::size_t scanIndexEnd) const override
 cumulate scan list into a trace
 
virtual Trace combineScansToTraceWithDowngradedMzResolution (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 combineScansToTraceWithDowngradedMzResolution2 (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
 
void combineScansInTofIndexIntensityMap (TimsDataFastMap &rawSpectrum, std::size_t scan_index_begin, std::size_t scan_index_end) const override
 cumulate scan list into a trace into a raw spectrum map
 
virtual void combineScansInTofIndexIntensityMap (TimsDataFastMap &tof_index_intensity_map, std::size_t scan_index_begin, std::size_t scan_index_end, quint32 tof_index_begin, quint32 tof_index_end) const override
 cumulate scan list into a trace into a raw spectrum map The intensities are NOT normalized with respect to the frame accumulation time
 
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 cumulateScanIntensities (std::size_t scanNum) const override
 
virtual quint64 cumulateScanRangeIntensities (std::size_t scanNumBegin, std::size_t scanNumEnd) const override
 ...
 
virtual std::vector< quint32 > getScanTofIndexList (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 > getScanIntensityList (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 index need the binary file
 
virtual std::vector< TofIndexIntensityPairgetRawValuePairList (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)
 
- Public Member Functions inherited from pappso::TimsFrameBase
 TimsFrameBase (std::size_t frameId, quint32 scanCount)
 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 scan_index) const final
 get the mass spectrum corresponding to a scan index
 
bool checkScanNum (std::size_t scanNum) const
 check that this scan number exists
 
void setAcqDurationInMilliseconds (double acquisition_duration_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 setRtInSeconds (double time)
 
void setMsMsType (quint8 type)
 
unsigned int getMsLevel () const
 
double getRtInSeconds () const
 
std::size_t getId () const
 
double getDriftTimeInMilliseconds (std::size_t scan_index) const
 get drift time of a scan number in milliseconds
 
double getOneOverK0Transformation (std::size_t scan_index) const
 get 1/K0 value of a given scan (mobility value)
 
std::size_t getScanIndexFromOneOverK0 (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 getTraceFromTofIndexIntensityMap (TimsDataFastMap &accumulated_scans) const
 transform accumulation of raw scans into a real mass spectrum
 
virtual const MzCalibrationInterfaceSPtrgetMzCalibrationInterfaceSPtr () const final
 get the MzCalibration model to compute mz and TOF for this frame
 
void setMzCalibrationInterfaceSPtr (MzCalibrationInterfaceSPtr mzCalibration)
 
virtual Trace getIonMobilityTraceByTofIndexRange (std::size_t tof_index_begin, std::size_t tof_index_end, XicExtractMethod method, std::size_t scan_index_begin, std::size_t scan_index_end) 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, TimsDataFastMap &accumulate_into) const
 cumulate a scan into a map
 
virtual void cumulateScan2 (std::size_t scanNum, TimsDataFastMap &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)
 
- Protected Member Functions inherited from pappso::TimsFrameBase
virtual std::vector< TofIndexIntensityPair > & downgradeResolutionOfTofIndexIntensityPairList (std::size_t tof_index_merge_window, std::vector< TofIndexIntensityPair > &spectrum) const
 Downgrade the TOF index resolution to lower the number of real m/z computations.
 

Protected Attributes

QByteArray m_binaryData
 
- Protected Attributes inherited from pappso::TimsFrameBase
quint32 m_scanCount
 total number of scans contained in this frame
 
std::size_t m_frameId
 Tims frame database id (the SQL identifier of this frame)
 
double m_acqDurationInMilliseconds = 0
 acquisition duration in milliseconds
 
quint8 m_msMsType = 0
 
double m_rtInSeconds = 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 52 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 60 of file timsframe.cpp.

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

References m_binaryData, pappso::TimsFrameBase::m_frameId, pappso::TimsFrameBase::m_scanCount, and unshufflePacket().

◆ TimsFrame() [2/3]

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

Copy constructor

Parameters
otherTODO

Definition at line 91 of file timsframe.cpp.

91 : TimsFrameBase(other)
92{
93}

◆ ~TimsFrame()

pappso::TimsFrame::~TimsFrame ( )
virtual

Destructor

Definition at line 95 of file timsframe.cpp.

96{
97}

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

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

Member Function Documentation

◆ combineScansInTofIndexIntensityMap() [1/2]

void pappso::TimsFrame::combineScansInTofIndexIntensityMap ( TimsDataFastMap & rawSpectrum,
std::size_t scan_index_begin,
std::size_t scan_index_end ) 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 672 of file timsframe.cpp.

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

References cumulateScan(), and m_binaryData.

◆ combineScansInTofIndexIntensityMap() [2/2]

void pappso::TimsFrame::combineScansInTofIndexIntensityMap ( TimsDataFastMap & tof_index_intensity_map,
std::size_t scan_index_begin,
std::size_t scan_index_end,
quint32 tof_index_begin,
quint32 tof_index_end ) const
overridevirtual

cumulate scan list into a trace into a raw spectrum map The intensities are NOT normalized with respect to the frame accumulation time

Parameters
tof_index_intensity_mapsimple map of integers to cumulate raw counts
scan_index_beginscan index in the frame in the order it lies in binary file, from 0 to N-1
scan_index_endscan index in the frame in the order it lies in binary file, from 0 to N-1
tof_index_begin
tof_index_end

Reimplemented from pappso::TimsFrameBase.

Definition at line 710 of file timsframe.cpp.

715{
716 qDebug() << "tof_index_begin=" << tof_index_begin
717 << " tof_index_end=" << tof_index_end;
718 //<< " mobility_scan_end=" << mobility_scan_end;
719
720 if(m_binaryData.size() == 0)
721 return;
722 try
723 {
724
725 std::size_t mobility_scan_max = scan_index_end + 1;
726 // if (mobility_scan_max > m_scanCount) mobility_scan_max = m_scanCount;
727 qDebug();
728 for(std::size_t i = scan_index_begin; i < mobility_scan_max; i++)
729 {
730 qDebug() << i;
731 cumulateScan2(i, rawSpectrum, tof_index_begin, tof_index_end);
732 qDebug() << i << rawSpectrum.getTofIndexList().size();
733 // local_accumulationTime += m_accumulationTime;
734 }
735 }
736
737 catch(std::exception &error)
738 {
739 qDebug() << QString("Failure in %1 %2 to %3 :\n %4")
740 .arg(__FUNCTION__)
741 .arg(scan_index_begin)
742 .arg(scan_index_end)
743 .arg(error.what());
744 }
745
746 // qDebug() << "end";
747}
virtual void cumulateScan2(std::size_t scanNum, TimsDataFastMap &accumulate_into, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const

References cumulateScan2(), pappso::TimsDataFastMap::getTofIndexList(), and m_binaryData.

◆ combineScansToTraceWithDowngradedMzResolution()

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

452{
453 // qDebug();
454
455 Trace new_trace;
456
457 try
458 {
459 if(m_binaryData.size() == 0)
460 {
461 qDebug() << "The frame is empty, returning empty trace.";
462 return new_trace;
463 }
464
465 // Allocate a map for (TOF,intensity) pairs to
466 // accumulate ion mobility scans.
467
468 TimsDataFastMap &raw_spectrum =
470 raw_spectrum.clear();
471 // double local_accumulationTime = 0;
472
473 std::size_t mobility_scan_max = mobility_scan_end + 1;
474
475 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
476 {
477 // qDebug() << "Going to cumulate currently iterated mobility scan:"
478 // << i;
479 cumulateScan(i, raw_spectrum);
480 // qDebug() << "Done cumulating currently iterated mobility scan:" <<
481 // i;
482
483 // local_accumulationTime += m_accumulationTime;
484 }
485
486 // qDebug();
487
488 pappso::DataPoint data_point_cumul;
489
490 MzCalibrationInterface *mz_calibration_p =
492
493 // If the caller asks that m/z values be binned larger than they are,
494 // ask that the m/z raw map be reduced in resolution.
495 if(mz_index_merge_window > 0)
496 {
497 raw_spectrum.downsizeMzRawMap(mz_index_merge_window);
498 }
499
500 // Store the first mz index and the last mz index of the current spectrum.
501 // The values are set to the out parameters.
502 mz_minimum_index_out = std::numeric_limits<quint32>::max();
503 mz_maximum_index_out = 0;
504
505 // FIXME: donc je comprends que les index sont contigus
506 // puisqu'on utilise at(key) ?
507 for(quint32 tof_index : raw_spectrum.getTofIndexList())
508 {
509 if(tof_index > mz_maximum_index_out)
510 mz_maximum_index_out = tof_index;
511 if(tof_index < mz_minimum_index_out)
512 mz_minimum_index_out = tof_index;
513
514 // Convert the TOF index to m/z
515 data_point_cumul.x = mz_calibration_p->getMzFromTofIndex(tof_index);
516
517 // Normalization
518 data_point_cumul.y = raw_spectrum.readIntensity(tof_index) *
519 ((double)100.0 / m_acqDurationInMilliseconds);
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}
static TimsDataFastMap & getTimsDataFastMapInstance()
double m_acqDurationInMilliseconds
acquisition duration 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 pappso::TimsDataFastMap::clear(), cumulateScan(), pappso::TimsDataFastMap::downsizeMzRawMap(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsDataFastMap::getTimsDataFastMapInstance(), pappso::TimsDataFastMap::getTofIndexList(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, m_binaryData, pappso::TimsDataFastMap::readIntensity(), pappso::DataPoint::x, and pappso::DataPoint::y.

Referenced by pappso::TimsFramesMsRunReader::readSpectrumCollection2().

◆ combineScansToTraceWithDowngradedMzResolution2()

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

558{
559 qDebug() << "Calling cumulateScansToTraceMzDownResolution2 for both mz and "
560 "im ranges accounting.";
561
562 Trace new_trace;
563
564 try
565 {
566 if(m_binaryData.size() == 0)
567 {
568 qDebug() << "The frame is empty, returning empty trace.";
569 return new_trace;
570 }
571
572 // Allocate a map for (TOF index,intensity) pairs to
573 // accumulate ion mobility scans.
574
575 TimsDataFastMap &raw_spectrum =
577 raw_spectrum.clear();
578 // double local_accumulationTime = 0;
579
580 std::size_t mobility_scan_max = mobility_scan_end + 1;
581
582 quint32 tof_index_for_mz_range_begin =
583 getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(
584 mz_range_begin);
585 quint32 tof_index_for_mz_range_end =
586 getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(mz_range_end);
587
588 qDebug() << "20240529 TOF index for mz range begin:"
589 << tof_index_for_mz_range_begin;
590 qDebug() << "20240529 TOF index for mz range end:"
591 << tof_index_for_mz_range_end;
592
593 for(std::size_t iter = mobility_scan_begin; iter < mobility_scan_max;
594 iter++)
595 {
596 // qDebug() << "Going to cumulate currently iterated mobility scan:"
597 // << iter;
598 cumulateScan2(iter,
599 raw_spectrum,
600 tof_index_for_mz_range_begin,
601 tof_index_for_mz_range_end);
602 // qDebug() << "Done cumulating currently iterated mobility scan:" <<
603 // i;
604
605 // local_accumulationTime += m_accumulationTime;
606 }
607
608 // qDebug();
609
610 pappso::DataPoint data_point_cumul;
611
612 MzCalibrationInterface *mz_calibration_p =
614
615 // If the caller asks that m/z values be binned larger than they are,
616 // ask that the m/z raw map be reduced in resolution.
617 if(mz_index_merge_window > 0)
618 {
619 raw_spectrum.downsizeMzRawMap(mz_index_merge_window);
620 }
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 for(quint32 tof_index : raw_spectrum.getTofIndexList())
629 {
630 std::size_t intensity = raw_spectrum.readIntensity(tof_index);
631 if(tof_index > mz_maximum_index_out)
632 mz_maximum_index_out = tof_index;
633 if(tof_index < mz_minimum_index_out)
634 mz_minimum_index_out = tof_index;
635
636 // Convert the TOF index to m/z
637 data_point_cumul.x = mz_calibration_p->getMzFromTofIndex(tof_index);
638
639 // Normalization
640 data_point_cumul.y =
641 intensity * ((double)100.0 / m_acqDurationInMilliseconds);
642
643 // Finally make the data point a new Trace point.
644 new_trace.push_back(data_point_cumul);
645 }
646
647 // qDebug() << "At this point we have mz_minimum_index_out:"
648 // << mz_minimum_index_out
649 // << "and mz_maximum_index_out:" << mz_maximum_index_out;
650
651 // FIXME: this does not seem to be necessary since raw_spectrum is a map
652 // with auto-sorting on the keys which are quint32.
653 // new_trace.sortX();
654
655 // qDebug();
656 }
657 catch(std::exception &error)
658 {
659 qDebug() << QString(
660 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
661 .arg(mobility_scan_begin, mobility_scan_end)
662 .arg(error.what());
663 }
664
665 // qDebug() << "Returning new trace of size:" << new_trace.size();
666
667 return new_trace;
668}

References pappso::TimsDataFastMap::clear(), cumulateScan2(), pappso::TimsDataFastMap::downsizeMzRawMap(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsDataFastMap::getTimsDataFastMapInstance(), pappso::TimsDataFastMap::getTofIndexList(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, m_binaryData, pappso::TimsDataFastMap::readIntensity(), pappso::DataPoint::x, and pappso::DataPoint::y.

Referenced by pappso::TimsFramesMsRunReader::readSpectrumCollection2().

◆ cumulateScan()

void pappso::TimsFrame::cumulateScan ( std::size_t scanNum,
TimsDataFastMap & 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 304 of file timsframe.cpp.

306{
307 qDebug();
308
309 if(m_binaryData.size() == 0)
310 return;
311 qDebug();
312 // checkScanNum(scanNum);
313
314 std::size_t scan_size = getScanPeakCount(scanNum);
315
316 std::size_t scan_offset = getScanOffset(scanNum);
317
318 qint32 previous = -1;
319 for(std::size_t i = 0; i < scan_size; i++)
320 {
321 quint32 x = (*(quint32 *)((m_binaryData.constData() + (scan_offset * 4) +
322 (i * 8))) +
323 previous);
324 quint32 y = (*(quint32 *)(m_binaryData.constData() + (scan_offset * 4) +
325 (i * 8) + 4));
326
327 previous = x;
328 qDebug() << "x=" << x << " y=" << y;
329 accumulate_into.accumulateIntensity(x, y);
330 }
331
332 qDebug();
333}
virtual std::size_t getScanPeakCount(std::size_t scanIndex) 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 pappso::TimsDataFastMap::accumulateIntensity(), getScanOffset(), getScanPeakCount(), m_binaryData, pappso::x, and pappso::y.

Referenced by combineScansInTofIndexIntensityMap(), combineScansToTraceWithDowngradedMzResolution(), and cumulateScansToTrace().

◆ cumulateScan2()

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

Reimplemented in pappso::TimsFrameType1.

Definition at line 337 of file timsframe.cpp.

341{
342 // qDebug();
343
344 if(m_binaryData.size() == 0)
345 return;
346
347 // checkScanNum(scanNum);
348
349 std::size_t scan_size = getScanPeakCount(scanNum);
350 std::size_t scan_offset = getScanOffset(scanNum);
351 qint32 previous = -1;
352
353 for(std::size_t i = 0; i < scan_size; i++)
354 {
355 quint32 x = (*(quint32 *)((m_binaryData.constData() + (scan_offset * 4) +
356 (i * 8))) +
357 previous);
358
359 previous = x;
360
361 if(x < accepted_tof_index_range_begin)
362 {
363
364 qDebug() << "TOF index still not in range, x:" << x;
365 continue;
366 }
367 if(x > accepted_tof_index_range_end)
368 {
369 qDebug() << "TOF index already out of range, x:" << x;
370 break;
371 }
372
373 qDebug() << "TOF index in range, x:" << x;
374
375 quint32 y = (*(quint32 *)(m_binaryData.constData() + (scan_offset * 4) +
376 (i * 8) + 4));
377
378 accumulate_into.accumulateIntensity(x, y);
379 }
380
381 // qDebug();
382}

References pappso::TimsDataFastMap::accumulateIntensity(), getScanOffset(), getScanPeakCount(), m_binaryData, pappso::x, and pappso::y.

Referenced by combineScansInTofIndexIntensityMap(), and combineScansToTraceWithDowngradedMzResolution2().

◆ cumulateScanIntensities()

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

Reimplemented from pappso::TimsFrameBase.

Definition at line 219 of file timsframe.cpp.

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

References getScanOffset(), getScanPeakCount(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, m_binaryData, pappso::x, and pappso::y.

Referenced by cumulateScanRangeIntensities().

◆ cumulateScanRangeIntensities()

quint64 pappso::TimsFrame::cumulateScanRangeIntensities ( 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 266 of file timsframe.cpp.

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

References cumulateScanIntensities(), and m_binaryData.

Referenced by pappso::TimsFramesMsRunReader::computeTicChromatogram().

◆ cumulateScansToTrace()

Trace pappso::TimsFrame::cumulateScansToTrace ( std::size_t scanIndexBegin,
std::size_t scanIndexEnd ) 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 386 of file timsframe.cpp.

388{
389 // qDebug();
390
391 Trace new_trace;
392
393 try
394 {
395 if(m_binaryData.size() == 0)
396 return new_trace;
397 TimsDataFastMap &raw_spectrum =
399 raw_spectrum.clear();
400 // double local_accumulationTime = 0;
401
402 std::size_t mobility_scan_max = mobility_scan_end + 1;
403 qDebug();
404 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
405 {
406 // qDebug() << i;
407 cumulateScan(i, raw_spectrum);
408 // qDebug() << i;
409
410 // local_accumulationTime += m_accumulationTime;
411 }
412
413 // qDebug();
414
415 pappso::DataPoint data_point_cumul;
416
417
418 MzCalibrationInterface *mz_calibration_p =
420
421
422 for(quint32 tof_index : raw_spectrum.getTofIndexList())
423 {
424 data_point_cumul.x = mz_calibration_p->getMzFromTofIndex(tof_index);
425 // normalization
426 data_point_cumul.y = raw_spectrum.readIntensity(tof_index) *
427 ((double)100.0 / m_acqDurationInMilliseconds);
428 new_trace.push_back(data_point_cumul);
429 }
430 new_trace.sortX();
431
432 // qDebug();
433 }
434
435 catch(std::exception &error)
436 {
437 qDebug() << QString(
438 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
439 .arg(mobility_scan_begin, mobility_scan_end)
440 .arg(error.what());
441 }
442 return new_trace;
443}

References pappso::TimsDataFastMap::clear(), cumulateScan(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsDataFastMap::getTimsDataFastMapInstance(), pappso::TimsDataFastMap::getTofIndexList(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, m_binaryData, pappso::TimsDataFastMap::readIntensity(), pappso::Trace::sortX(), pappso::DataPoint::x, and pappso::DataPoint::y.

◆ extractTimsXicListInRtRange()

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

Definition at line 867 of file timsframe.cpp.

871{
872 qDebug() << std::distance(itXicListbegin, itXicListend);
873
874 std::vector<TimsFrame::XicComputeStructure> tmp_xic_list;
875
876 for(auto it = itXicListbegin; it != itXicListend; it++)
877 {
878 tmp_xic_list.push_back(TimsFrame::XicComputeStructure(this, **it));
879
880 qDebug() << " tmp_xic_struct.mobilityIndexBegin="
881 << tmp_xic_list.back().mobilityIndexBegin
882 << " tmp_xic_struct.mobilityIndexEnd="
883 << tmp_xic_list.back().mobilityIndexEnd;
884
885 qDebug() << " tmp_xic_struct.mzIndexLowerBound="
886 << tmp_xic_list.back().mzIndexLowerBound
887 << " tmp_xic_struct.mzIndexUpperBound="
888 << tmp_xic_list.back().mzIndexUpperBound;
889 }
890 if(tmp_xic_list.size() == 0)
891 return;
892 /*
893 std::sort(tmp_xic_list.begin(), tmp_xic_list.end(), [](const
894 TimsXicStructure &a, const TimsXicStructure &b) { return
895 a.mobilityIndexBegin < b.mobilityIndexBegin;
896 });
897 */
898 std::vector<std::size_t> unique_scan_num_list;
899 for(auto &&struct_xic : tmp_xic_list)
900 {
901 for(std::size_t scan = struct_xic.mobilityIndexBegin;
902 (scan <= struct_xic.mobilityIndexEnd) && (scan < m_scanCount);
903 scan++)
904 {
905 unique_scan_num_list.push_back(scan);
906 }
907 }
908 std::sort(unique_scan_num_list.begin(), unique_scan_num_list.end());
909 auto it_scan_num_end =
910 std::unique(unique_scan_num_list.begin(), unique_scan_num_list.end());
911 auto it_scan_num = unique_scan_num_list.begin();
912
913 while(it_scan_num != it_scan_num_end)
914 {
915 TraceSPtr ms_spectrum = getRawTraceSPtr(*it_scan_num);
916 // qDebug() << ms_spectrum.get()->toString();
917 for(auto &&tmp_xic_struct : tmp_xic_list)
918 {
919 if(((*it_scan_num) >= tmp_xic_struct.mobilityIndexBegin) &&
920 ((*it_scan_num) <= tmp_xic_struct.mobilityIndexEnd))
921 {
922 if(method == XicExtractMethod::max)
923 {
924 tmp_xic_struct.tmpIntensity +=
925 ms_spectrum.get()->maxY(tmp_xic_struct.mzIndexLowerBound,
926 tmp_xic_struct.mzIndexUpperBound);
927
928 qDebug() << "tmp_xic_struct.tmpIntensity="
929 << tmp_xic_struct.tmpIntensity;
930 }
931 else
932 {
933 // sum
934 tmp_xic_struct.tmpIntensity +=
935 ms_spectrum.get()->sumY(tmp_xic_struct.mzIndexLowerBound,
936 tmp_xic_struct.mzIndexUpperBound);
937 qDebug() << "tmp_xic_struct.tmpIntensity="
938 << tmp_xic_struct.tmpIntensity;
939 }
940 }
941 }
942 it_scan_num++;
943 }
944
945 for(auto &&tmp_xic_struct : tmp_xic_list)
946 {
947 if(tmp_xic_struct.tmpIntensity != 0)
948 {
949 qDebug() << tmp_xic_struct.xic_ptr;
950 tmp_xic_struct.xic_ptr->push_back(
951 {m_rtInSeconds, tmp_xic_struct.tmpIntensity});
952 }
953 }
954
955 qDebug();
956}
double m_rtInSeconds
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_rtInSeconds, pappso::TimsFrameBase::m_scanCount, and pappso::max.

Referenced by pappso::TimsDirectXicExtractor::protectedExtractXicCoordSPtrList().

◆ getMassSpectrumSPtr()

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

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

Parameters
scan_indexscan index 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 750 of file timsframe.cpp.

751{
752
753 // qDebug() << " scanNum=" << scanNum;
754
755 checkScanNum(scanNum);
756
757 // qDebug();
758
759 pappso::MassSpectrumSPtr mass_spectrum_sptr =
760 std::make_shared<pappso::MassSpectrum>();
761 // std::vector<DataPoint>
762
763 if(m_binaryData.size() == 0)
764 return mass_spectrum_sptr;
765
766 // qDebug();
767
768 std::size_t size = getScanPeakCount(scanNum);
769
770 std::size_t offset = getScanOffset(scanNum);
771
772 MzCalibrationInterface *mz_calibration_p =
774
775
776 qint32 previous = -1;
777 qint32 tof_index;
778 // std::vector<quint32> index_list;
779 DataPoint data_point;
780 for(std::size_t i = 0; i < size; i++)
781 {
782 tof_index =
783 (*(quint32 *)((m_binaryData.constData() + (offset * 4) + (i * 8))) +
784 previous);
785 data_point.y =
786 (*(quint32 *)(m_binaryData.constData() + (offset * 4) + (i * 8) + 4));
787
788 // intensity normalization
789 data_point.y *= 100.0 / m_acqDurationInMilliseconds;
790
791 previous = tof_index;
792
793
794 // mz calibration
795 data_point.x = mz_calibration_p->getMzFromTofIndex(tof_index);
796 mass_spectrum_sptr.get()->push_back(data_point);
797 }
798
799 // qDebug();
800
801 return mass_spectrum_sptr;
802}
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(), getScanOffset(), getScanPeakCount(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, m_binaryData, 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 806 of file timsframe.cpp.

812{
813 qDebug() << "mz_range_begin:" << mz_range_begin
814 << "mz_range_end:" << mz_range_end
815 << "mz_index_merge_window:" << mz_index_merge_window;
816
817 Trace spectrum;
818
819 quint32 mz_index_begin = 0;
820 quint32 mz_index_end = std::numeric_limits<quint32>::max();
821
822 if(mz_range_end > 0)
823 {
824 qDebug() << "m/z range is requested.";
825
826 mz_index_begin =
827 msp_mzCalibration.get()->getTofIndexFromMz(mz_range_begin);
828 mz_index_end = msp_mzCalibration.get()->getTofIndexFromMz(mz_range_end);
829 }
830
831 qDebug() << "After conversion of mz indices, mz_index_begin:"
832 << mz_index_begin << "mz_index_end;" << mz_index_end;
833
834 auto raw_spectrum =
835 getRawValuePairList(scanNum, mz_index_begin, mz_index_end);
836
837 qDebug() << " raw_spectrum.size();" << raw_spectrum.size();
838
839 if(mz_index_merge_window > 0)
840 {
841 qDebug() << "mz_index_merge_window;=" << mz_index_merge_window
842 << " raw_spectrum.size()=" << raw_spectrum.size();
844 mz_index_merge_window, raw_spectrum);
845 }
846
847 if(raw_spectrum.size() > 0)
848 {
849 mz_minimum_index_out = raw_spectrum.front().tof_index;
850 mz_maximum_index_out = raw_spectrum.back().tof_index;
851
852 for(auto &&element : raw_spectrum)
853 {
854 spectrum.push_back(DataPoint(
855 msp_mzCalibration.get()->getMzFromTofIndex(element.tof_index),
856 static_cast<double>(element.intensity_index)));
857
858 // intensity normalization
859 spectrum.back().y *= 100.0 / m_acqDurationInMilliseconds;
860 }
861 }
862
863 return spectrum;
864}
MzCalibrationInterfaceSPtr msp_mzCalibration
virtual std::vector< TofIndexIntensityPair > & downgradeResolutionOfTofIndexIntensityPairList(std::size_t tof_index_merge_window, std::vector< TofIndexIntensityPair > &spectrum) const
Downgrade the TOF index resolution to lower the number of real m/z computations.
virtual std::vector< TofIndexIntensityPair > 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::downgradeResolutionOfTofIndexIntensityPairList(), getRawValuePairList(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, and pappso::TimsFrameBase::msp_mzCalibration.

Referenced by pappso::TimsMsRunReader::readSpectrumCollection2().

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

961{
962
963 // qDebug();
964
965 pappso::TraceSPtr trace_sptr = std::make_shared<pappso::Trace>();
966 // std::vector<DataPoint>
967
968 if(m_binaryData.size() == 0)
969 return trace_sptr;
970 // qDebug();
971
972 std::size_t size = getScanPeakCount(scanNum);
973
974 std::size_t offset = getScanOffset(scanNum);
975
976 qint32 previous = -1;
977 std::vector<quint32> index_list;
978 for(std::size_t i = 0; i < size; i++)
979 {
980 DataPoint data_point(
981 (*(quint32 *)((m_binaryData.constData() + (offset * 4) + (i * 8))) +
982 previous),
983 (*(quint32 *)(m_binaryData.constData() + (offset * 4) + (i * 8) + 4)));
984
985 // intensity normalization
986 data_point.y *= 100.0 / m_acqDurationInMilliseconds;
987
988 previous = data_point.x;
989 trace_sptr.get()->push_back(data_point);
990 }
991 // qDebug();
992 return trace_sptr;
993}

References getScanOffset(), getScanPeakCount(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, m_binaryData, pappso::DataPoint::x, and pappso::DataPoint::y.

Referenced by extractTimsXicListInRtRange().

◆ getRawValuePairList()

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

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

1000{
1001 // qDebug() << accepted_tof_index_range_begin;
1002
1003 std::vector<TimsFrame::TofIndexIntensityPair> raw_value_pairs;
1004 // std::vector<DataPoint>
1005
1006 if(m_binaryData.size() == 0)
1007 return raw_value_pairs;
1008 // qDebug();
1009
1010 std::size_t size = getScanPeakCount(scanNum);
1011
1012 std::size_t offset = getScanOffset(scanNum);
1013
1014 // qDebug() << size;
1015 qint32 previous = -1;
1016 std::vector<quint32> index_list;
1017 for(std::size_t i = 0; i < size; i++)
1018 {
1019
1020 // qDebug() << i;
1021 TimsFrame::TofIndexIntensityPair raw_value_pair(
1022 {(*(quint32 *)((m_binaryData.constData() + (offset * 4) + (i * 8))) +
1023 previous),
1024 (*(quint32 *)(m_binaryData.constData() + (offset * 4) + (i * 8) +
1025 4))});
1026
1027 previous = raw_value_pair.tof_index;
1028 if(raw_value_pair.tof_index < accepted_tof_index_range_begin)
1029 {
1030 // qDebug() << "TOF index still not in range, x:" << x;
1031 continue;
1032 }
1033 if(raw_value_pair.tof_index > accepted_tof_index_range_end)
1034 {
1035 // qDebug() << "TOF index already out of range, x:" << x;
1036 break;
1037 }
1038
1039 raw_value_pairs.push_back(raw_value_pair);
1040 }
1041 qDebug() << raw_value_pairs.size();
1042 return raw_value_pairs;
1043}

References getScanOffset(), getScanPeakCount(), m_binaryData, and pappso::TimsFrameBase::TofIndexIntensityPair::tof_index.

Referenced by getMobilityScan().

◆ getScanIntensityList()

std::vector< quint32 > pappso::TimsFrame::getScanIntensityList ( 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 195 of file timsframe.cpp.

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

References pappso::TimsFrameBase::checkScanNum(), getScanOffset(), getScanPeakCount(), and m_binaryData.

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

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

References m_binaryData.

Referenced by cumulateScan(), cumulateScan2(), cumulateScanIntensities(), getMassSpectrumSPtr(), getRawTraceSPtr(), getRawValuePairList(), getScanIntensityList(), and getScanTofIndexList().

◆ getScanPeakCount()

std::size_t pappso::TimsFrame::getScanPeakCount ( std::size_t scanIndex) const
overridevirtual

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

Parameters
scanIndexscan index in the frame in the order it lies in frame's binary data, from 0 to N-1

Reimplemented from pappso::TimsFrameBase.

Reimplemented in pappso::TimsFrameType1.

Definition at line 128 of file timsframe.cpp.

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

References pappso::TimsFrameBase::checkScanNum(), m_binaryData, and pappso::TimsFrameBase::m_scanCount.

Referenced by cumulateScan(), cumulateScan2(), cumulateScanIntensities(), getMassSpectrumSPtr(), getRawTraceSPtr(), getRawValuePairList(), getScanIntensityList(), and getScanTofIndexList().

◆ getScanTofIndexList()

std::vector< quint32 > pappso::TimsFrame::getScanTofIndexList ( 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 170 of file timsframe.cpp.

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

References pappso::TimsFrameBase::checkScanNum(), getScanOffset(), getScanPeakCount(), and m_binaryData.

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

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

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

References m_binaryData.

Referenced by TimsFrame().

Member Data Documentation

◆ m_binaryData

◆ TimsDirectXicExtractor

friend pappso::TimsFrame::TimsDirectXicExtractor
private

Definition at line 54 of file timsframe.h.


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