libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
timsframe.cpp
Go to the documentation of this file.
1/**
2 * \file pappsomspp/vendors/tims/timsframe.cpp
3 * \date 23/08/2019
4 * \author Olivier Langella
5 * \brief handle a single Bruker's TimsTof frame
6 */
7
8/*******************************************************************************
9 * Copyright (c) 2019 Olivier Langella <Olivier.Langella@u-psud.fr>.
10 *
11 * This file is part of the PAPPSOms++ library.
12 *
13 * PAPPSOms++ is free software: you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation, either version 3 of the License, or
16 * (at your option) any later version.
17 *
18 * PAPPSOms++ is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with PAPPSOms++. If not, see <http://www.gnu.org/licenses/>.
25 *
26 ******************************************************************************/
27
28#include "timsframe.h"
29#include "../../../pappsomspp/pappsoexception.h"
30#include <QDebug>
31#include <QObject>
32#include <QtEndian>
33#include <memory>
34
35
36namespace pappso
37{
38
40 const TimsFrame *fram_p, const XicCoordTims &xic_struct)
41{
42 xic_ptr = xic_struct.xicSptr.get();
43
45 mobilityIndexEnd = xic_struct.scanNumEnd;
47 fram_p->getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(
48 xic_struct.mzRange.lower()); // convert mz to raw digitizer value
50 fram_p->getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(
51 xic_struct.mzRange.upper());
52 tmpIntensity = 0;
53}
54
55TimsFrame::TimsFrame(std::size_t timsId, quint32 scanNum)
56 : TimsFrameBase(timsId, scanNum)
57{
58 // m_timsDataFrame.resize(10);
59}
60
61TimsFrame::TimsFrame(std::size_t timsId,
62 quint32 scanNum,
63 char *p_bytes,
64 std::size_t len)
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}
91
93{
94}
95
99
100
101void
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}
127
128std::size_t
129TimsFrame::getNbrPeaks(std::size_t scanNum) const
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}
157
158std::size_t
159TimsFrame::getScanOffset(std::size_t scanNum) const
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}
168
169
170std::vector<quint32>
171TimsFrame::getScanIndexList(std::size_t scanNum) const
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}
194
195std::vector<quint32>
196TimsFrame::getScanIntensities(std::size_t scanNum) const
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}
217
218
219quint64
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}
257
258
259/**
260 * @brief ...
261 *
262 * @param mobility_scan_begin p_mobility_scan_begin:...
263 * @param mobility_scan_end p_mobility_scan_end:...
264 * @return quint64
265 */
266quint64
267TimsFrame::cumulateScansIntensities(std::size_t mobility_scan_begin,
268 std::size_t mobility_scan_end) const
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}
302
303
304void
305TimsFrame::cumulateScan(std::size_t scanNum,
306 std::map<quint32, quint32> &accumulate_into) const
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}
341
342// Proof of concept m/z range-conditions for accumulations
343void
344TimsFrame::cumulateScan2(std::size_t scanNum,
345 std::map<quint32, quint32> &accumulate_into,
346 quint32 accepted_tof_index_range_begin,
347 quint32 accepted_tof_index_range_end) const
348{
349 // qDebug();
350
351 if(m_timsDataFrame.size() == 0)
352 return;
353
354 // checkScanNum(scanNum);
355
356 std::size_t scan_size = getNbrPeaks(scanNum);
357 std::size_t scan_offset = getScanOffset(scanNum);
358 qint32 previous = -1;
359
360 for(std::size_t i = 0; i < scan_size; i++)
361 {
362 quint32 x = (*(quint32 *)((m_timsDataFrame.constData() +
363 (scan_offset * 4) + (i * 8))) +
364 previous);
365
366 if(x < accepted_tof_index_range_begin)
367 {
368 // qDebug() << "TOF index still not in range, x:" << x;
369 continue;
370 }
371 if(x > accepted_tof_index_range_end)
372 {
373 // qDebug() << "TOF index already out of range, x:" << x;
374 break;
375 }
376
377 // qDebug() << "TOF index in range, x:" << x;
378
379 quint32 y = (*(quint32 *)(m_timsDataFrame.constData() +
380 (scan_offset * 4) + (i * 8) + 4));
381
382 previous = x;
383
384 auto ret = accumulate_into.insert(std::pair<quint32, quint32>(x, y));
385
386 if(ret.second == false)
387 {
388 // already existed : cumulate
389 ret.first->second += y;
390 }
391 }
392
393 // qDebug();
394}
395
396
397Trace
398TimsFrame::cumulateScansToTrace(std::size_t mobility_scan_begin,
399 std::size_t mobility_scan_end) const
400{
401 // qDebug();
402
403 Trace new_trace;
404
405 try
406 {
407 if(m_timsDataFrame.size() == 0)
408 return new_trace;
409 std::map<quint32, quint32> raw_spectrum;
410 // double local_accumulationTime = 0;
411
412 std::size_t mobility_scan_max = mobility_scan_end + 1;
413 qDebug();
414 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
415 {
416 // qDebug() << i;
417 cumulateScan(i, raw_spectrum);
418 // qDebug() << i;
419
420 // local_accumulationTime += m_accumulationTime;
421 }
422
423 // qDebug();
424
425 pappso::DataPoint data_point_cumul;
426
427
428 MzCalibrationInterface *mz_calibration_p =
430
431
432 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
433 {
434 data_point_cumul.x =
435 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
436 // normalization
437 data_point_cumul.y =
438 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
439 new_trace.push_back(data_point_cumul);
440 }
441 new_trace.sortX();
442
443 // qDebug();
444 }
445
446 catch(std::exception &error)
447 {
448 qDebug() << QString(
449 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
450 .arg(mobility_scan_begin, mobility_scan_end)
451 .arg(error.what());
452 }
453 return new_trace;
454}
455
456Trace
458 std::size_t mz_index_merge_window,
459 std::size_t mobility_scan_begin,
460 std::size_t mobility_scan_end,
461 quint32 &mz_minimum_index_out,
462 quint32 &mz_maximum_index_out) const
463{
464 // qDebug();
465
466 Trace new_trace;
467
468 try
469 {
470 if(m_timsDataFrame.size() == 0)
471 {
472 qDebug() << "The frame is empty, returning empty trace.";
473 return new_trace;
474 }
475
476 // Allocate a map for (TOF,intensity) pairs to
477 // accumulate ion mobility scans.
478
479 std::map<quint32, quint32> raw_spectrum;
480 // double local_accumulationTime = 0;
481
482 std::size_t mobility_scan_max = mobility_scan_end + 1;
483
484 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
485 {
486 // qDebug() << "Going to cumulate currently iterated mobility scan:"
487 // << i;
488 cumulateScan(i, raw_spectrum);
489 // qDebug() << "Done cumulating currently iterated mobility scan:" <<
490 // i;
491
492 // local_accumulationTime += m_accumulationTime;
493 }
494
495 // qDebug();
496
497 pappso::DataPoint data_point_cumul;
498
499 MzCalibrationInterface *mz_calibration_p =
501
502 // If the caller asks that m/z values be binned larger than they are,
503 // ask that the m/z raw map be reduced in resolution.
504 if(mz_index_merge_window > 0)
505 raw_spectrum = downsizeMzRawMap(mz_index_merge_window, raw_spectrum);
506
507 // Store the first mz index and the last mz index of the current spectrum.
508 // The values are set to the out parameters.
509 mz_minimum_index_out = std::numeric_limits<quint32>::max();
510 mz_maximum_index_out = 0;
511
512 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
513 {
514 if(pair_tof_intensity.first > mz_maximum_index_out)
515 mz_maximum_index_out = pair_tof_intensity.first;
516 if(pair_tof_intensity.first < mz_minimum_index_out)
517 mz_minimum_index_out = pair_tof_intensity.first;
518
519 // Convert the TOF index to m/z
520 data_point_cumul.x =
521 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
522
523 // Normalization
524 data_point_cumul.y =
525 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
526
527 // Finally make the data point a new Trace point.
528 new_trace.push_back(data_point_cumul);
529 }
530
531 // qDebug() << "At this point we have mz_minimum_index_out:"
532 // << mz_minimum_index_out
533 // << "and mz_maximum_index_out:" << mz_maximum_index_out;
534
535 // FIXME: this does not seem to be necessary since raw_spectrum is a map
536 // with auto-sorting on the keys which are quint32.
537 // new_trace.sortX();
538
539 // qDebug();
540 }
541 catch(std::exception &error)
542 {
543 qDebug() << QString(
544 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
545 .arg(mobility_scan_begin, mobility_scan_end)
546 .arg(error.what());
547 }
548
549 // qDebug() << "Returning new trace of size:" << new_trace.size();
550
551 return new_trace;
552}
553
554
555Trace
557 std::size_t mz_index_merge_window,
558 double mz_range_begin,
559 double mz_range_end,
560 std::size_t mobility_scan_begin,
561 std::size_t mobility_scan_end,
562 quint32 &mz_minimum_index_out,
563 quint32 &mz_maximum_index_out) const
564{
565 // qDebug();
566
567 Trace new_trace;
568
569 try
570 {
571 if(m_timsDataFrame.size() == 0)
572 {
573 qDebug() << "The frame is empty, returning empty trace.";
574 return new_trace;
575 }
576
577 // Allocate a map for (TOF index,intensity) pairs to
578 // accumulate ion mobility scans.
579
580 std::map<quint32, quint32> raw_spectrum;
581 // double local_accumulationTime = 0;
582
583 std::size_t mobility_scan_max = mobility_scan_end + 1;
584
585 quint32 only_in_mz_begin_tof_index_range =
586 getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(
587 mz_range_begin);
588 quint32 only_in_mz_end_tof_index_range =
589 getMzCalibrationInterfaceSPtr().get()->getTofIndexFromMz(mz_range_end);
590
591 // qDebug() << "20231129 TOF index range begin:"
592 // << only_in_mz_begin_tof_index_range;
593 // qDebug() << "20231129 TOF index range end:"
594 // << only_in_mz_end_tof_index_range;
595
596 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
597 {
598 // qDebug() << "Going to cumulate currently iterated mobility scan:"
599 // << i;
601 raw_spectrum,
602 only_in_mz_begin_tof_index_range,
603 only_in_mz_end_tof_index_range);
604 // qDebug() << "Done cumulating currently iterated mobility scan:" <<
605 // i;
606
607 // local_accumulationTime += m_accumulationTime;
608 }
609
610 // qDebug();
611
612 pappso::DataPoint data_point_cumul;
613
614 MzCalibrationInterface *mz_calibration_p =
616
617 // If the caller asks that m/z values be binned larger than they are,
618 // ask that the m/z raw map be reduced in resolution.
619 if(mz_index_merge_window > 0)
620 raw_spectrum = downsizeMzRawMap(mz_index_merge_window, raw_spectrum);
621
622 // Store the first mz index and the last mz index of the current spectrum.
623 // The values are set to the out parameters.
624 mz_minimum_index_out = std::numeric_limits<quint32>::max();
625 mz_maximum_index_out = 0;
626
627 for(std::pair<quint32, quint32> pair_tof_intensity : raw_spectrum)
628 {
629 if(pair_tof_intensity.first > mz_maximum_index_out)
630 mz_maximum_index_out = pair_tof_intensity.first;
631 if(pair_tof_intensity.first < mz_minimum_index_out)
632 mz_minimum_index_out = pair_tof_intensity.first;
633
634 // Convert the TOF index to m/z
635 data_point_cumul.x =
636 mz_calibration_p->getMzFromTofIndex(pair_tof_intensity.first);
637
638 // Normalization
639 data_point_cumul.y =
640 pair_tof_intensity.second * ((double)100.0 / m_accumulationTime);
641
642 // Finally make the data point a new Trace point.
643 new_trace.push_back(data_point_cumul);
644 }
645
646 // qDebug() << "At this point we have mz_minimum_index_out:"
647 // << mz_minimum_index_out
648 // << "and mz_maximum_index_out:" << mz_maximum_index_out;
649
650 // FIXME: this does not seem to be necessary since raw_spectrum is a map
651 // with auto-sorting on the keys which are quint32.
652 // new_trace.sortX();
653
654 // qDebug();
655 }
656 catch(std::exception &error)
657 {
658 qDebug() << QString(
659 "Failure in TimsFrame::cumulateScanToTrace %1 to %2 :\n %3")
660 .arg(mobility_scan_begin, mobility_scan_end)
661 .arg(error.what());
662 }
663
664 // qDebug() << "Returning new trace of size:" << new_trace.size();
665
666 return new_trace;
667}
668
669
670void
671TimsFrame::cumulateScansInRawMap(std::map<quint32, quint32> &rawSpectrum,
672 std::size_t mobility_scan_begin,
673 std::size_t mobility_scan_end) const
674{
675 // qDebug() << "begin mobility_scan_begin=" << mobility_scan_begin
676 //<< " mobility_scan_end=" << mobility_scan_end;
677
678 if(m_timsDataFrame.size() == 0)
679 return;
680 try
681 {
682
683 std::size_t mobility_scan_max = mobility_scan_end + 1;
684 qDebug();
685 for(std::size_t i = mobility_scan_begin; i < mobility_scan_max; i++)
686 {
687 qDebug() << i;
688 cumulateScan(i, rawSpectrum);
689 qDebug() << i;
690 // local_accumulationTime += m_accumulationTime;
691 }
692 }
693
694 catch(std::exception &error)
695 {
696 qDebug() << QString("Failure in %1 %2 to %3 :\n %4")
697 .arg(__FUNCTION__)
698 .arg(mobility_scan_begin)
699 .arg(mobility_scan_end)
700 .arg(error.what());
701 }
702
703 // qDebug() << "end";
704}
705
706
708TimsFrame::getMassSpectrumSPtr(std::size_t scanNum) const
709{
710
711 // qDebug() << " scanNum=" << scanNum;
712
713 checkScanNum(scanNum);
714
715 // qDebug();
716
717 pappso::MassSpectrumSPtr mass_spectrum_sptr =
718 std::make_shared<pappso::MassSpectrum>();
719 // std::vector<DataPoint>
720
721 if(m_timsDataFrame.size() == 0)
722 return mass_spectrum_sptr;
723
724 // qDebug();
725
726 std::size_t size = getNbrPeaks(scanNum);
727
728 std::size_t offset = getScanOffset(scanNum);
729
730 MzCalibrationInterface *mz_calibration_p =
732
733
734 qint32 previous = -1;
735 qint32 tof_index;
736 // std::vector<quint32> index_list;
737 DataPoint data_point;
738 for(std::size_t i = 0; i < size; i++)
739 {
740 tof_index =
741 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
742 previous);
743 data_point.y = (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) +
744 (i * 8) + 4));
745
746 // intensity normalization
747 data_point.y *= 100.0 / m_accumulationTime;
748
749 previous = tof_index;
750
751
752 // mz calibration
753 data_point.x = mz_calibration_p->getMzFromTofIndex(tof_index);
754 mass_spectrum_sptr.get()->push_back(data_point);
755 }
756
757 // qDebug();
758
759 return mass_spectrum_sptr;
760}
761
762
763Trace
764TimsFrame::getMobilityScan(std::size_t scanNum,
765 std::size_t mz_index_merge_window,
766 double mz_range_begin,
767 double mz_range_end,
768 quint32 &mz_minimum_index_out,
769 quint32 &mz_maximum_index_out) const
770{
771 // qDebug();
772 qDebug() << "mz_index_merge_window=" << mz_index_merge_window;
773 Trace spectrum;
774 quint32 mz_index_begin = 0;
775 quint32 mz_index_end = std::numeric_limits<quint32>::max();
776 if(mz_range_end > 0)
777 {
778 // qDebug();
779 mz_index_begin =
780 msp_mzCalibration.get()->getTofIndexFromMz(mz_range_begin);
781 mz_index_end = msp_mzCalibration.get()->getTofIndexFromMz(mz_range_end);
782 }
783 auto raw_spectrum =
784 getRawValuePairList(scanNum, mz_index_begin, mz_index_end);
785 qDebug() << "mz_index_begin=" << mz_index_begin
786 << " mz_index_end=" << mz_index_end;
787 qDebug() << "mz_index_merge_window=" << mz_index_merge_window
788 << " raw_spectrum.size()=" << raw_spectrum.size();
789
790 if(mz_index_merge_window > 0)
791 {
792 qDebug() << "mz_index_merge_window=" << mz_index_merge_window
793 << " raw_spectrum.size()=" << raw_spectrum.size();
794 raw_spectrum =
795 downsizeMzRawValuePairList(mz_index_merge_window, raw_spectrum);
796 }
797
798 if(raw_spectrum.size() > 0)
799 {
800 mz_minimum_index_out = raw_spectrum.front().mz_tof_index;
801 mz_maximum_index_out = raw_spectrum.back().mz_tof_index;
802
803 // qDebug();
804 for(auto &&element : raw_spectrum)
805 {
806 spectrum.push_back(
807 {msp_mzCalibration.get()->getMzFromTofIndex(element.mz_tof_index),
808 (double)element.intensity_index});
809
810 // intensity normalization
811 spectrum.back().y *= 100.0 / m_accumulationTime;
812 }
813 }
814 // qDebug();
815 return spectrum;
816}
817
818void
820 std::vector<XicCoordTims *>::iterator &itXicListbegin,
821 std::vector<XicCoordTims *>::iterator &itXicListend,
822 XicExtractMethod method) const
823{
824 qDebug() << std::distance(itXicListbegin, itXicListend);
825
826 std::vector<TimsFrame::XicComputeStructure> tmp_xic_list;
827
828 for(auto it = itXicListbegin; it != itXicListend; it++)
829 {
830 tmp_xic_list.push_back(TimsFrame::XicComputeStructure(this, **it));
831
832 qDebug() << " tmp_xic_struct.mobilityIndexBegin="
833 << tmp_xic_list.back().mobilityIndexBegin
834 << " tmp_xic_struct.mobilityIndexEnd="
835 << tmp_xic_list.back().mobilityIndexEnd;
836
837 qDebug() << " tmp_xic_struct.mzIndexLowerBound="
838 << tmp_xic_list.back().mzIndexLowerBound
839 << " tmp_xic_struct.mzIndexUpperBound="
840 << tmp_xic_list.back().mzIndexUpperBound;
841 }
842 if(tmp_xic_list.size() == 0)
843 return;
844 /*
845 std::sort(tmp_xic_list.begin(), tmp_xic_list.end(), [](const
846 TimsXicStructure &a, const TimsXicStructure &b) { return
847 a.mobilityIndexBegin < b.mobilityIndexBegin;
848 });
849 */
850 std::vector<std::size_t> unique_scan_num_list;
851 for(auto &&struct_xic : tmp_xic_list)
852 {
853 for(std::size_t scan = struct_xic.mobilityIndexBegin;
854 (scan <= struct_xic.mobilityIndexEnd) && (scan < m_scanNumber);
855 scan++)
856 {
857 unique_scan_num_list.push_back(scan);
858 }
859 }
860 std::sort(unique_scan_num_list.begin(), unique_scan_num_list.end());
861 auto it_scan_num_end =
862 std::unique(unique_scan_num_list.begin(), unique_scan_num_list.end());
863 auto it_scan_num = unique_scan_num_list.begin();
864
865 while(it_scan_num != it_scan_num_end)
866 {
867 TraceSPtr ms_spectrum = getRawTraceSPtr(*it_scan_num);
868 // qDebug() << ms_spectrum.get()->toString();
869 for(auto &&tmp_xic_struct : tmp_xic_list)
870 {
871 if(((*it_scan_num) >= tmp_xic_struct.mobilityIndexBegin) &&
872 ((*it_scan_num) <= tmp_xic_struct.mobilityIndexEnd))
873 {
874 if(method == XicExtractMethod::max)
875 {
876 tmp_xic_struct.tmpIntensity +=
877 ms_spectrum.get()->maxY(tmp_xic_struct.mzIndexLowerBound,
878 tmp_xic_struct.mzIndexUpperBound);
879
880 qDebug() << "tmp_xic_struct.tmpIntensity="
881 << tmp_xic_struct.tmpIntensity;
882 }
883 else
884 {
885 // sum
886 tmp_xic_struct.tmpIntensity +=
887 ms_spectrum.get()->sumY(tmp_xic_struct.mzIndexLowerBound,
888 tmp_xic_struct.mzIndexUpperBound);
889 qDebug() << "tmp_xic_struct.tmpIntensity="
890 << tmp_xic_struct.tmpIntensity;
891 }
892 }
893 }
894 it_scan_num++;
895 }
896
897 for(auto &&tmp_xic_struct : tmp_xic_list)
898 {
899 if(tmp_xic_struct.tmpIntensity != 0)
900 {
901 qDebug() << tmp_xic_struct.xic_ptr;
902 tmp_xic_struct.xic_ptr->push_back(
903 {m_time, tmp_xic_struct.tmpIntensity});
904 }
905 }
906
907 qDebug();
908}
909
910
912TimsFrame::getRawTraceSPtr(std::size_t scanNum) const
913{
914
915 // qDebug();
916
917 pappso::TraceSPtr trace_sptr = std::make_shared<pappso::Trace>();
918 // std::vector<DataPoint>
919
920 if(m_timsDataFrame.size() == 0)
921 return trace_sptr;
922 // qDebug();
923
924 std::size_t size = getNbrPeaks(scanNum);
925
926 std::size_t offset = getScanOffset(scanNum);
927
928 qint32 previous = -1;
929 std::vector<quint32> index_list;
930 for(std::size_t i = 0; i < size; i++)
931 {
932 DataPoint data_point(
933 (*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
934 previous),
935 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
936 4)));
937
938 // intensity normalization
939 data_point.y *= 100.0 / m_accumulationTime;
940
941 previous = data_point.x;
942 trace_sptr.get()->push_back(data_point);
943 }
944 // qDebug();
945 return trace_sptr;
946}
947
948
949std::vector<TimsFrame::RawValuePair>
951 quint32 accepted_tof_index_range_begin,
952 quint32 accepted_tof_index_range_end) const
953{
954 // qDebug();
955
956 std::vector<TimsFrame::RawValuePair> trace_sptr;
957 // std::vector<DataPoint>
958
959 if(m_timsDataFrame.size() == 0)
960 return trace_sptr;
961 // qDebug();
962
963 std::size_t size = getNbrPeaks(scanNum);
964
965 std::size_t offset = getScanOffset(scanNum);
966
967 // qDebug() << size;
968 qint32 previous = -1;
969 std::vector<quint32> index_list;
970 for(std::size_t i = 0; i < size; i++)
971 {
972
973 // qDebug() << i;
974 TimsFrame::RawValuePair data_point(
975 {(*(quint32 *)((m_timsDataFrame.constData() + (offset * 4) + (i * 8))) +
976 previous),
977 (*(quint32 *)(m_timsDataFrame.constData() + (offset * 4) + (i * 8) +
978 4))});
979 if(data_point.mz_tof_index < accepted_tof_index_range_begin)
980 {
981 // qDebug() << "TOF index still not in range, x:" << x;
982 continue;
983 }
984 if(data_point.mz_tof_index > accepted_tof_index_range_end)
985 {
986 // qDebug() << "TOF index already out of range, x:" << x;
987 break;
988 }
989
990
991 previous = data_point.mz_tof_index;
992 trace_sptr.push_back(data_point);
993 }
994 qDebug() << trace_sptr.size();
995 return trace_sptr;
996}
997
998} // namespace pappso
virtual double getMzFromTofIndex(quint32 tof_index)=0
get m/z from time of flight raw index
pappso_double lower() const
Definition mzrange.h:71
pappso_double upper() const
Definition mzrange.h:77
double m_accumulationTime
accumulation time in milliseconds
virtual std::vector< RawValuePair > & downsizeMzRawValuePairList(std::size_t mzindex_merge_window, std::vector< RawValuePair > &spectrum) const
downsize mz resolution to lower the number of real mz computations
virtual std::map< quint32, quint32 > & downsizeMzRawMap(std::size_t mzindex_merge_window, std::map< quint32, quint32 > &rawSpectrum) const
downsize mz resolution to lower the number of real mz computations
MzCalibrationInterfaceSPtr msp_mzCalibration
double m_time
retention time
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)
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
QByteArray m_timsDataFrame
Definition timsframe.h:279
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::size_t getNbrPeaks(std::size_t scanNum) const override
get the number of peaks in this spectrum need the binary file
virtual Trace cumulateScansToTraceMzDownResolution(std::size_t mzindex_merge_window, std::size_t scanNumBegin, std::size_t scanNumEnd, quint32 &mz_minimum_index, quint32 &mz_maximum_index) const override
cumulate spectrum given a scan number range need the binary file The intensities are normalized with ...
virtual ~TimsFrame()
Definition timsframe.cpp:96
virtual quint64 cumulateScansIntensities(std::size_t scanNumBegin, std::size_t scanNumEnd) const override
...
virtual Trace cumulateScansToTraceMzDownResolution2(std::size_t mz_index_merge_window, double mz_range_begin, double mz_range_end, std::size_t mobility_scan_begin, std::size_t mobility_scan_end, quint32 &mz_minimum_index_out, quint32 &mz_maximum_index_out) const override
cumulate spectrum given a scan number range need the binary file The intensities are normalized with ...
virtual Trace cumulateScansToTrace(std::size_t scanNumBegin, std::size_t scanNumEnd) const override
cumulate scan list into a trace
virtual void cumulateScan2(std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const
virtual void cumulateScan(std::size_t scanNum, std::map< quint32, quint32 > &accumulate_into) const
cumulate a scan into a map
TimsFrame(std::size_t timsId, quint32 scanNum, char *p_bytes, std::size_t len)
Definition timsframe.cpp:61
virtual std::vector< RawValuePair > getRawValuePairList(std::size_t scanNum, quint32 accepted_tof_index_range_begin, quint32 accepted_tof_index_range_end) const
get the raw index tof_index and intensities (normalized)
virtual pappso::MassSpectrumSPtr getMassSpectrumSPtr(std::size_t scanNum) const override
get Mass spectrum with peaks for this scan number need the binary file
virtual quint64 cumulateSingleScanIntensities(std::size_t scanNum) const override
virtual std::vector< quint32 > getScanIntensities(std::size_t scanNum) const override
get raw intensities without transformation from one scan it needs intensity normalization
void unshufflePacket(const char *src)
unshuffle data packet of tims compression type 2
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
std::size_t getScanOffset(std::size_t scanNum) const
get offset for this spectrum in the binary file
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
void extractTimsXicListInRtRange(std::vector< XicCoordTims * >::iterator &itXicListbegin, std::vector< XicCoordTims * >::iterator &itXicListend, XicExtractMethod method) const
virtual pappso::TraceSPtr getRawTraceSPtr(std::size_t scanNum) const
get the raw index tof_index and intensities (normalized)
A simple container of DataPoint instances.
Definition trace.h:148
void sortX(SortOrder sort_order=SortOrder::ascending)
Definition trace.cpp:1086
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
std::shared_ptr< Trace > TraceSPtr
Definition trace.h:135
std::shared_ptr< MassSpectrum > MassSpectrumSPtr
XicExtractMethod
Definition types.h:240
@ max
maximum of intensities
pappso_double x
Definition datapoint.h:23
pappso_double y
Definition datapoint.h:24
XicComputeStructure(const TimsFrame *fram_p, const XicCoordTims &xic_struct)
Definition timsframe.cpp:39
coordinates of the XIC to extract and the resulting XIC after extraction
std::size_t scanNumEnd
mobility index end
std::size_t scanNumBegin
mobility index begin
XicSPtr xicSptr
extracted xic
Definition xiccoord.h:130
MzRange mzRange
the mass to extract
Definition xiccoord.h:120
handle a single Bruker's TimsTof frame