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

#include <timsframetype1.h>

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

Public Member Functions

 TimsFrameType1 (std::size_t timsId, quint32 scanNum, char *p_bytes, std::size_t len)
 
 TimsFrameType1 (const TimsFrameType1 &other)
 
virtual ~TimsFrameType1 ()
 
virtual std::size_t getScanPeakCount (std::size_t scanNum) const override
 get the number of peaks in this spectrum need the binary file
 
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 the mass spectrum corresponding to a scan number
 
- Public Member Functions inherited from pappso::TimsFrame
 TimsFrame (std::size_t timsId, quint32 scanNum, char *p_bytes, std::size_t len)
 
 TimsFrame (const TimsFrame &other)
 
virtual ~TimsFrame ()
 
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
 ...
 
- 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

virtual void cumulateScan (std::size_t scanNum, TimsDataFastMap &accumulate_into) const override
 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 override
 
virtual pappso::TraceSPtr getRawTraceSPtr (std::size_t scanNum) const override
 get the raw index tof_index and intensities (normalized)
 
virtual std::vector< TofIndexIntensityPairgetRawValuePairList (std::size_t scanNum, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const override
 get the raw index tof_index and intensities (normalized)
 
- Protected Member Functions inherited from pappso::TimsFrame
 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
 
- 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.
 

Private Member Functions

void copyAndLzfDecompress (const char *src, std::size_t len)
 copy buffer header and lzf decompress each scan for tims compression type 1
 
unsigned int lzfDecompressScan (const char *src, unsigned int src_len, char *dest, unsigned int dest_len)
 decompress a single LZF compressed scan buffer
 

Private Attributes

std::vector< std::size_t > m_scanOffsetList
 
std::vector< std::size_t > m_scanSizeList
 

Additional Inherited Members

- Protected Attributes inherited from pappso::TimsFrame
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
 

Detailed Description

Todo:
write docs

Definition at line 37 of file timsframetype1.h.

Constructor & Destructor Documentation

◆ TimsFrameType1() [1/2]

pappso::TimsFrameType1::TimsFrameType1 ( 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 41 of file timsframetype1.cpp.

45 : TimsFrame(timsId, scanNum)
46{
47 qDebug() << timsId;
48 m_binaryData.resize(len * 2);
49
50 if(p_bytes != nullptr)
51 {
52 qDebug() << timsId;
53 copyAndLzfDecompress(p_bytes, len);
54 qDebug() << timsId;
55 }
56 else
57 {
58 if(m_scanCount == 0)
59 {
60
62 QObject::tr(
63 "TimsFrameType1::TimsFrameType1(%1,%2,nullptr,%3) FAILED")
64 .arg(m_frameId)
65 .arg(m_scanCount)
66 .arg(len));
67 }
68 }
69}
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)
void copyAndLzfDecompress(const char *src, std::size_t len)
copy buffer header and lzf decompress each scan for tims compression type 1
TimsFrame(std::size_t timsId, quint32 scanNum, char *p_bytes, std::size_t len)
Definition timsframe.cpp:60
QByteArray m_binaryData
Definition timsframe.h:287

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

◆ TimsFrameType1() [2/2]

pappso::TimsFrameType1::TimsFrameType1 ( const TimsFrameType1 other)

Copy constructor

Parameters
otherTODO

Definition at line 71 of file timsframetype1.cpp.

71 : TimsFrame(other)
72{
73}

◆ ~TimsFrameType1()

pappso::TimsFrameType1::~TimsFrameType1 ( )
virtual

Destructor

Definition at line 75 of file timsframetype1.cpp.

76{
77}

Member Function Documentation

◆ copyAndLzfDecompress()

void pappso::TimsFrameType1::copyAndLzfDecompress ( const char *  src,
std::size_t  len 
)
private

copy buffer header and lzf decompress each scan for tims compression type 1

Parameters
srcraw data buffer containing scan offsets and LZF compressed scans
lenlength of the data buffer

Definition at line 81 of file timsframetype1.cpp.

82{
83
84 qDebug() << " m_scanNumber=" << m_scanCount << " len=" << len;
85 // the start position offset for each scan and the length of the last scan
86 // copy first m_scanNumber*4 bytes in qbyte array
87 std::size_t count = (m_scanCount + 2) * 4;
88
89 qDebug() << " count=" << count;
90 if(m_binaryData.size() < (long)(count + count))
91 {
92 qDebug() << " m_timsDataFrame.size()=" << m_binaryData.size();
93 m_binaryData.resize(count + count);
94 }
95
96 /*
97 std::size_t decompressed_size =
98 lzfDecompressScan(src + 3687 - 8,
99 9,
100 m_timsDataFrame.data() + 3660,
101 m_timsDataFrame.size() - 3660);
102
103 qDebug() << "decompressed_size=" << decompressed_size;
104 */
105 // memcpy(m_timsDataFrame.data(), src, count);
106
107 qDebug() << "offset begin at last :" << count + 4;
108
109 // std::vector<std::size_t> compressed_len_list;
110 std::size_t offset;
111 std::size_t previous_offset = (*(quint32 *)(src));
112 qDebug() << "first offset= " << previous_offset;
113 std::size_t cumul_decompressed_size = 0;
114
115
116 for(quint32 i = 1; i <= m_scanCount; i++)
117 {
118 offset = (*(quint32 *)(src + (i * 4)));
119
120 std::size_t compressed_size = offset - previous_offset;
121
122 qDebug() << "scan i=" << i << " previous_offset=" << previous_offset
123 << " offset=" << offset << " length=" << compressed_size;
124 // compressed_len_list.push_back(offset - previous_offset);
125 std::size_t remaining_size = m_binaryData.size();
126
127 if(cumul_decompressed_size < remaining_size)
128 {
129 remaining_size = remaining_size - cumul_decompressed_size;
130 }
131 else
132 {
133 remaining_size = 0;
134 }
135 qDebug() << " remaining_size=" << remaining_size;
136 std::size_t decompressed_size =
137 lzfDecompressScan(src + previous_offset - 8,
138 compressed_size,
139 m_binaryData.data() + cumul_decompressed_size,
140 remaining_size);
141
142
143 m_scanOffsetList.push_back(cumul_decompressed_size);
144 m_scanSizeList.push_back(decompressed_size / 4);
145 cumul_decompressed_size += decompressed_size;
146 qDebug() << " decompressed_size=" << decompressed_size;
147
148
149 previous_offset = offset;
150 }
151 /*
152 std::size_t last_offset = (*(quint32 *)(src + (m_scanNumber * 4)));
153 qDebug() << "last scan length :" << last_offset;
154
155 qDebug() << "last scan length bonus:"
156 << (*(quint32 *)(src + (m_scanNumber + 1 * 4)));
157
158 qDebug() << " m_scanOffsetList.size()=" << m_scanOffsetList.size()
159 << " m_scanNumber=" << m_scanNumber;
160 */
161 /*
162 throw PappsoException(
163 QObject::tr("ERROR reading TimsFrameType1 ").arg(m_timsId));
164 */
165}
std::vector< std::size_t > m_scanSizeList
unsigned int lzfDecompressScan(const char *src, unsigned int src_len, char *dest, unsigned int dest_len)
decompress a single LZF compressed scan buffer
std::vector< std::size_t > m_scanOffsetList

References lzfDecompressScan(), pappso::TimsFrame::m_binaryData, pappso::TimsFrameBase::m_scanCount, m_scanOffsetList, and m_scanSizeList.

Referenced by TimsFrameType1().

◆ cumulateScan()

void pappso::TimsFrameType1::cumulateScan ( std::size_t  scanNum,
TimsDataFastMap accumulate_into 
) const
overrideprotectedvirtual

cumulate a scan into a map

Parameters
scanNumscan number 0 to (m_scanNumber-1)

Reimplemented from pappso::TimsFrame.

Definition at line 219 of file timsframetype1.cpp.

221{
222 if(m_binaryData.size() == 0)
223 return;
224 // checkScanNum(scanNum);
225
226
227 std::size_t size = m_scanSizeList[scanNum];
228
229 std::size_t offset = m_scanOffsetList[scanNum];
230
231 // qDebug() << "begin offset=" << offset << " size=" << size;
232 qint32 value = 0;
233 qint32 tof_index = 0;
234 for(std::size_t i = 0; i < size; i++)
235 {
236 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
237 // qDebug() << " i=" << i << " value=" << value;
238
239 if(value < 0)
240 {
241 tof_index += -1 * value;
242 }
243 else
244 {
245
246 quint32 x = tof_index;
247 quint32 y = value;
248
249 accumulate_into.accumulateIntensity(x, y);
250
251 tof_index++;
252 }
253 }
254 qDebug() << "end";
255}

References pappso::TimsDataFastMap::accumulateIntensity(), pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, pappso::x, and pappso::y.

◆ cumulateScan2()

void pappso::TimsFrameType1::cumulateScan2 ( std::size_t  scanNum,
TimsDataFastMap accumulate_into,
quint32  accepted_tof_index_range_begin,
quint32  accepted_tof_index_range_end 
) const
overrideprotectedvirtual

Reimplemented from pappso::TimsFrame.

Definition at line 259 of file timsframetype1.cpp.

263{
264 if(m_binaryData.size() == 0)
265 return;
266 // checkScanNum(scanNum);
267
268
269 std::size_t size = m_scanSizeList[scanNum];
270
271 std::size_t offset = m_scanOffsetList[scanNum];
272
273 // qDebug() << "begin offset=" << offset << " size=" << size;
274 qint32 value = 0;
275 qint32 tof_index = 0;
276 for(std::size_t i = 0; i < size; i++)
277 {
278 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
279 // qDebug() << " i=" << i << " value=" << value;
280
281 if(value < 0)
282 {
283 tof_index += -1 * value;
284 }
285 else
286 {
287
288 quint32 x = tof_index;
289 quint32 y = value;
290
291
292 if(x < accepted_tof_index_range_begin)
293 {
294 tof_index++;
295 continue;
296 }
297 if(x > accepted_tof_index_range_end)
298 {
299 break;
300 }
301 accumulate_into.accumulateIntensity(x, y);
302
303 tof_index++;
304 }
305 }
306 qDebug() << "end";
307}

References pappso::TimsDataFastMap::accumulateIntensity(), pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, pappso::x, and pappso::y.

◆ getMassSpectrumSPtr()

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

get the mass spectrum corresponding to a scan number

Parameters
scanNumthe scan number to retrieve

Reimplemented from pappso::TimsFrame.

Definition at line 430 of file timsframetype1.cpp.

431{
432
433 qDebug() << " scanNum=" << scanNum;
434
435 checkScanNum(scanNum);
436
437 try
438 {
439 qDebug();
440
441 pappso::MassSpectrumSPtr mass_spectrum_sptr =
442 std::make_shared<pappso::MassSpectrum>();
443 // std::vector<DataPoint>
444
445 if(m_binaryData.size() == 0)
446 return mass_spectrum_sptr;
447 qDebug();
448
449 std::size_t size = m_scanSizeList[scanNum];
450
451 std::size_t offset = m_scanOffsetList[scanNum];
452
453 qDebug() << " offset=" << offset << " size=" << size;
454 if(size == 0)
455 return mass_spectrum_sptr;
456
457
458 MzCalibrationInterface *mz_calibration_p =
460
461
462 qint32 value = 0;
463 qint32 tof_index = 0;
464 // std::vector<quint32> index_list;
465 DataPoint data_point;
466 for(std::size_t i = 0; i < size; i++)
467 {
468 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
469
470 if(value < 0)
471 {
472 tof_index += -1 * value;
473 }
474 else
475 {
476 data_point.y = value;
477
478 // intensity normalization
479 data_point.y *= 100.0 / m_acqDurationInMilliseconds;
480
481
482 // mz calibration
483 data_point.x = mz_calibration_p->getMzFromTofIndex(tof_index);
484 mass_spectrum_sptr.get()->push_back(data_point);
485 tof_index++;
486 }
487 }
488
489
490 qDebug() << mass_spectrum_sptr.get()->toString();
491 return mass_spectrum_sptr;
492 }
493 catch(PappsoException &error)
494 {
496 QObject::tr("Error TimsFrameType1::getMassSpectrumSPtr frameId=%1 "
497 "scanNum=%2 :\n%3")
498 .arg(getId())
499 .arg(scanNum)
500 .arg(error.qwhat()));
501 }
502}
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
bool checkScanNum(std::size_t scanNum) const
check that this scan number exists
std::size_t getId() const
std::shared_ptr< MassSpectrum > MassSpectrumSPtr

References pappso::TimsFrameBase::checkScanNum(), pappso::TimsFrameBase::getId(), pappso::TimsFrameBase::getMzCalibrationInterfaceSPtr(), pappso::MzCalibrationInterface::getMzFromTofIndex(), pappso::TimsFrameBase::m_acqDurationInMilliseconds, pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, pappso::PappsoException::qwhat(), pappso::DataPoint::x, and pappso::DataPoint::y.

Referenced by getScanPeakCount().

◆ getRawTraceSPtr()

pappso::TraceSPtr pappso::TimsFrameType1::getRawTraceSPtr ( std::size_t  scanNum) const
overrideprotectedvirtual

get the raw index tof_index and intensities (normalized)

Parameters
scanNumthe scan number to extract
Returns
trace vector

Reimplemented from pappso::TimsFrame.

Definition at line 506 of file timsframetype1.cpp.

507{
508
509 // qDebug();
510
511 pappso::TraceSPtr trace_sptr = std::make_shared<pappso::Trace>();
512 // std::vector<DataPoint>
513
514 if(m_binaryData.size() == 0)
515 return trace_sptr;
516 qDebug();
517
518 std::size_t size = m_scanSizeList[scanNum];
519
520 std::size_t offset = m_scanOffsetList[scanNum];
521
522 qDebug() << " offset=" << offset << " size=" << size;
523 if(size == 0)
524 return trace_sptr;
525
526 // qDebug();
527 qint32 value = 0;
528 qint32 tof_index = 0;
529
530 // std::vector<quint32> index_list;
531 DataPoint data_point;
532 for(std::size_t i = 0; i < size; i++)
533 {
534 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
535
536 if(value < 0)
537 {
538 tof_index += -1 * value;
539 }
540 else
541 {
542 data_point.y = value;
543
544 // intensity normalization
545 data_point.y *= 100.0 / m_acqDurationInMilliseconds;
546
547
548 // mz calibration
549 data_point.x = tof_index;
550 trace_sptr.get()->push_back(data_point);
551 tof_index++;
552 }
553 }
554
555
556 // qDebug();
557 return trace_sptr;
558}
std::shared_ptr< Trace > TraceSPtr
Definition trace.h:135

References pappso::TimsFrameBase::m_acqDurationInMilliseconds, pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, pappso::DataPoint::x, and pappso::DataPoint::y.

◆ getRawValuePairList()

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

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 from pappso::TimsFrame.

Definition at line 562 of file timsframetype1.cpp.

565{
566
567 // qDebug();
568
569 std::vector<TimsFrame::TofIndexIntensityPair> trace_sptr;
570 // std::vector<DataPoint>
571
572 if(m_binaryData.size() == 0)
573 return trace_sptr;
574 qDebug();
575
576 std::size_t size = m_scanSizeList[scanNum];
577
578 std::size_t offset = m_scanOffsetList[scanNum];
579
580 qDebug() << " offset=" << offset << " size=" << size;
581 if(size == 0)
582 return trace_sptr;
583
584 // qDebug();
585 qint32 value = 0;
586 qint32 tof_index = 0;
587
588 // std::vector<quint32> index_list;
589 TimsFrame::TofIndexIntensityPair data_point;
590 for(std::size_t i = 0; i < size; i++)
591 {
592 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
593
594 if(value < 0)
595 {
596 tof_index += -1 * value;
597 }
598 else
599 {
600 data_point.intensity_index = value;
601
602 if(data_point.intensity_index < accepted_tof_index_range_begin)
603 {
604 tof_index++;
605 continue;
606 }
607 if(data_point.intensity_index > accepted_tof_index_range_end)
608 {
609 break;
610 }
611 // intensity normalization
612 data_point.intensity_index *= 100.0 / m_acqDurationInMilliseconds;
613
614
615 // mz calibration
616 data_point.tof_index = tof_index;
617 trace_sptr.push_back(data_point);
618 tof_index++;
619 }
620 }
621
622
623 // qDebug();
624 return trace_sptr;
625}

References pappso::TimsFrameBase::TofIndexIntensityPair::intensity_index, pappso::TimsFrameBase::m_acqDurationInMilliseconds, pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, and pappso::TimsFrameBase::TofIndexIntensityPair::tof_index.

◆ getScanIntensityList()

std::vector< quint32 > pappso::TimsFrameType1::getScanIntensityList ( std::size_t  scanNum) const
overridevirtual

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

Reimplemented from pappso::TimsFrame.

Definition at line 369 of file timsframetype1.cpp.

370{
371
372
373 qDebug() << " scanNum=" << scanNum;
374
375 checkScanNum(scanNum);
376
377 std::vector<quint32> int_values;
378
379 try
380 {
381 qDebug();
382
383
384 if(m_binaryData.size() == 0)
385 return int_values;
386 qDebug();
387
388 std::size_t size = m_scanSizeList[scanNum];
389
390 std::size_t offset = m_scanOffsetList[scanNum];
391
392 qDebug() << " offset=" << offset << " size=" << size;
393 if(size == 0)
394 return int_values;
395
396 qint32 value = 0;
397 qint32 tof_index = 0;
398 // std::vector<quint32> index_list;
399 for(std::size_t i = 0; i < size; i++)
400 {
401 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
402
403 if(value < 0)
404 {
405 tof_index += -1 * value;
406 }
407 else
408 {
409 int_values.push_back(value);
410 tof_index++;
411 }
412 }
413
414
415 qDebug();
416 return int_values;
417 }
418 catch(PappsoException &error)
419 {
420 throw pappso::PappsoException(QObject::tr("Error %1 frameId=%2 "
421 "scanNum=%3 :\n%4")
422 .arg(__FUNCTION__)
423 .arg(getId())
424 .arg(scanNum)
425 .arg(error.qwhat()));
426 }
427}

References pappso::TimsFrameBase::checkScanNum(), pappso::TimsFrameBase::getId(), pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, and pappso::PappsoException::qwhat().

◆ getScanPeakCount()

std::size_t pappso::TimsFrameType1::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::TimsFrame.

Definition at line 211 of file timsframetype1.cpp.

212{
213 pappso::MassSpectrumSPtr mass_spectrum_sptr = getMassSpectrumSPtr(scanNum);
214 return mass_spectrum_sptr.get()->size();
215}
virtual pappso::MassSpectrumSPtr getMassSpectrumSPtr(std::size_t scanNum) const override
get the mass spectrum corresponding to a scan number

References getMassSpectrumSPtr().

◆ getScanTofIndexList()

std::vector< quint32 > pappso::TimsFrameType1::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::TimsFrame.

Definition at line 310 of file timsframetype1.cpp.

311{
312 qDebug();
313 checkScanNum(scanNum);
314
315 std::vector<quint32> mzindex_values;
316
317 try
318 {
319 qDebug();
320
321
322 if(m_binaryData.size() == 0)
323 return mzindex_values;
324 qDebug();
325
326 std::size_t size = m_scanSizeList[scanNum];
327
328 std::size_t offset = m_scanOffsetList[scanNum];
329
330 qDebug() << " offset=" << offset << " size=" << size;
331 if(size == 0)
332 return mzindex_values;
333
334 qint32 value = 0;
335 qint32 tof_index = 0;
336 // std::vector<quint32> index_list;
337 for(std::size_t i = 0; i < size; i++)
338 {
339 value = (*(qint32 *)(m_binaryData.constData() + offset + (i * 4)));
340
341 if(value < 0)
342 {
343 tof_index += -1 * value;
344 }
345 else
346 {
347 mzindex_values.push_back(tof_index);
348 tof_index++;
349 }
350 }
351
352
353 qDebug();
354 return mzindex_values;
355 }
356 catch(PappsoException &error)
357 {
358 throw pappso::PappsoException(QObject::tr("Error %1 frameId=%2 "
359 "scanNum=%3 :\n%4")
360 .arg(__FUNCTION__)
361 .arg(getId())
362 .arg(scanNum)
363 .arg(error.qwhat()));
364 }
365 qDebug();
366}

References pappso::TimsFrameBase::checkScanNum(), pappso::TimsFrameBase::getId(), pappso::TimsFrame::m_binaryData, m_scanOffsetList, m_scanSizeList, and pappso::PappsoException::qwhat().

◆ lzfDecompressScan()

unsigned int pappso::TimsFrameType1::lzfDecompressScan ( const char *  src,
unsigned int  src_len,
char *  dest,
unsigned int  dest_len 
)
private

decompress a single LZF compressed scan buffer

Parameters
srcpointer on the LZF compressed buffer
src_lenlength of the source buffer
destpointer to the destination buffer (in the qbyte array)
dest_lenlength of the destination buffer (max possible in the qbytearray)
Returns
scan decompressed size

Definition at line 169 of file timsframetype1.cpp.

173{
174 qDebug() << "src=" << src << " src_len=" << src_len
175 << " dest_len=" << dest_len;
176 if(src_len == 0)
177 return 0;
178 unsigned int decompressed_size;
179 unsigned int more_space = src_len * 2;
180 decompressed_size = lzf_decompress(src, src_len, dest, dest_len);
181 while(decompressed_size == 0)
182 {
183 qDebug() << "dest_len=" << dest_len;
184 qDebug() << "decompressed_size=" << decompressed_size;
185
186 if(errno == EINVAL)
187 {
188 throw PappsoException(
189 QObject::tr("ERROR reading TimsFrameType1 %1 TIMS binary file %2: "
190 "LZF decompression error EINVAL")
191 .arg(m_frameId));
192 }
193 else if(errno == E2BIG)
194 {
195 qDebug() << " m_timsDataFrame.size()=" << m_binaryData.size()
196 << " more_space=" << more_space;
197 m_binaryData.resize(m_binaryData.size() + more_space);
198 dest_len += more_space;
199 qDebug();
200 decompressed_size = lzf_decompress(src, src_len, dest, dest_len);
201 }
202 else
203 {
204 break;
205 }
206 }
207 return decompressed_size;
208}

References pappso::TimsFrame::m_binaryData, and pappso::TimsFrameBase::m_frameId.

Referenced by copyAndLzfDecompress().

Member Data Documentation

◆ m_scanOffsetList

std::vector<std::size_t> pappso::TimsFrameType1::m_scanOffsetList
private

◆ m_scanSizeList

std::vector<std::size_t> pappso::TimsFrameType1::m_scanSizeList
private

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