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

#include <timsframesmsrunreader.h>

Inheritance diagram for pappso::TimsFramesMsRunReader:
pappso::TimsMsRunReaderBase pappso::MsRunReader

Public Member Functions

 TimsFramesMsRunReader (MsRunIdCstSPtr &msrun_id_csp)
 
virtual ~TimsFramesMsRunReader ()
 
virtual MassSpectrumSPtr massSpectrumSPtr (std::size_t spectrum_index) override
 get a MassSpectrumSPtr class given its spectrum index
 
virtual MassSpectrumCstSPtr massSpectrumCstSPtr (std::size_t spectrum_index) override
 
virtual QualifiedMassSpectrum qualifiedMassSpectrum (std::size_t spectrum_index, bool want_binary_data=true) const override
 get a QualifiedMassSpectrum class given its scan number
 
virtual void readSpectrumCollection (SpectrumCollectionHandlerInterface &handler) override
 function to visit an MsRunReader and get each Spectrum in a spectrum collection handler
 
virtual void readSpectrumCollection2 (const MsRunReadConfig &config, SpectrumCollectionHandlerInterface &handler) override
 
virtual void readSpectrumCollectionByMsLevel (SpectrumCollectionHandlerInterface &handler, unsigned int ms_level) override
 function to visit an MsRunReader and get each Spectrum in a spectrum collection handler by Ms Levels
 
virtual std::size_t spectrumListSize () const override
 get the totat number of spectrum conained in the MSrun data file
 
virtual Trace computeTicChromatogram ()
 
- Public Member Functions inherited from pappso::TimsMsRunReaderBase
 TimsMsRunReaderBase (MsRunIdCstSPtr &msrun_id_csp)
 
 TimsMsRunReaderBase (const TimsMsRunReaderBase &msrun_reader_base)
 
virtual ~TimsMsRunReaderBase ()
 
virtual TimsDataSp getTimsDataSPtr ()
 give an access to the underlying raw data pointer
 
virtual bool hasScanNumbers () const override
 tells if spectra can be accessed using scan numbers by default, it returns false. Only overrided functions can check if scan numbers are available in the current file
 
virtual bool releaseDevice () override
 release data back end device if a the data back end is released, the developper has to use acquireDevice before using the msrunreader object
 
virtual bool acquireDevice () override
 acquire data back end device
 
virtual Trace getTicChromatogram () override
 get a TIC chromatogram
 
virtual std::vector< double > getRetentionTimeLine () override
 retention timeline get retention times along the MSrun in seconds
 
virtual pappso::XicCoordSPtr newXicCoordSPtrFromSpectrumIndex (std::size_t spectrum_index, pappso::PrecisionPtr precision) const override
 get a xic coordinate object from a given spectrum index
 
virtual pappso::XicCoordSPtr newXicCoordSPtrFromQualifiedMassSpectrum (const pappso::QualifiedMassSpectrum &mass_spectrum, pappso::PrecisionPtr precision) const override
 get a xic coordinate object from a given spectrum
 
- Public Member Functions inherited from pappso::MsRunReader
 MsRunReader (const MsRunIdCstSPtr &ms_run_id)
 
 MsRunReader (const MsRunReader &other)
 
virtual ~MsRunReader ()
 
const MsRunIdCstSPtrgetMsRunId () const
 
virtual std::size_t scanNumber2SpectrumIndex (std::size_t scan_number)
 if possible, converts a scan number into a spectrum index This is a convenient function to help transition from the old scan number (not implemented by all vendors) to more secure spectrum index (not vendor dependant). It is better to not rely on this function.
 
void setMonoThread (bool is_mono_thread)
 set only one is_mono_thread to true
 
bool isMonoThread () const
 

Friends

class MsFileAccessor
 

Additional Inherited Members

- Protected Member Functions inherited from pappso::TimsMsRunReaderBase
virtual void initialize () override
 
virtual bool accept (const QString &file_name) const override
 tells if the reader is able to handle this file must be implemented by private MS run reader, specific of one or more file format
 
- Protected Attributes inherited from pappso::TimsMsRunReaderBase
TimsDataSp msp_timsData = nullptr
 
- Protected Attributes inherited from pappso::MsRunReader
MsRunIdCstSPtr mcsp_msRunId
 
MsRunReaderScanNumberMultiMapmpa_multiMapScanNumber = nullptr
 

Detailed Description

Definition at line 42 of file timsframesmsrunreader.h.

Constructor & Destructor Documentation

◆ TimsFramesMsRunReader()

TimsFramesMsRunReader::TimsFramesMsRunReader ( MsRunIdCstSPtr msrun_id_csp)
Todo:
write docs

Definition at line 37 of file timsframesmsrunreader.cpp.

◆ ~TimsFramesMsRunReader()

TimsFramesMsRunReader::~TimsFramesMsRunReader ( )
virtual

Definition at line 42 of file timsframesmsrunreader.cpp.

43{
44 msp_timsData = nullptr;
45}

References pappso::TimsMsRunReaderBase::msp_timsData.

Member Function Documentation

◆ computeTicChromatogram()

Trace TimsFramesMsRunReader::computeTicChromatogram ( )
virtual

Definition at line 504 of file timsframesmsrunreader.cpp.

505{
506
507 // We want to compute the TIC chromatogram, not load the chromatogram that
508 // is located in the SQL database.
509 //
510 // For this, we need to iterated into the frames and ask for MS1 spectra
511 // only. msp_timsData has that information:
512 //
513 // std::vector<FrameIdDescr> m_frameIdDescrList;
514 //
515 // and
516
517 // struct FrameIdDescr
518 // {
519 // std::size_t m_frameId; // frame id
520 // std::size_t m_size; // frame size (number of TOF scans in frame)
521 // std::size_t m_cumulSize; // cumulative size
522 // };
523
524 Trace tic_chromatogram;
525
526 const std::vector<FrameIdDescr> frame_descr_list =
527 msp_timsData->getFrameIdDescrList();
528
529 for(FrameIdDescr frame_id_descr : frame_descr_list)
530 {
531 TimsFrameCstSPtr tims_frame_csp =
532 msp_timsData->getTimsFrameCstSPtrCached(frame_id_descr.m_frameId);
533 std::size_t scan_begin = 0;
534 std::size_t scan_end = tims_frame_csp->getTotalNumberOfScans() - 1;
535
536 // By convention, a TIC chromatogram is only performed using MS1
537 // spectra.
538 if(tims_frame_csp->getMsLevel() == 1)
539 {
540
541 // Retention times are in seconds in the Bruker world.
542 double rt = tims_frame_csp->getRtInSeconds();
543
544 tic_chromatogram.append(
546 tims_frame_csp->cumulateScanRangeIntensities(scan_begin,
547 scan_end)));
548 }
549 else
550 continue;
551 }
552
553 return tic_chromatogram;
554}
A simple container of DataPoint instances.
Definition trace.h:148
size_t append(const DataPoint &data_point)
appends a datapoint and return new size
Definition trace.cpp:648
@ rt
Retention time.
std::shared_ptr< const TimsFrame > TimsFrameCstSPtr
Definition timsframe.h:43

References pappso::Trace::append(), pappso::TimsMsRunReaderBase::msp_timsData, and pappso::rt.

◆ massSpectrumCstSPtr()

pappso::MassSpectrumCstSPtr TimsFramesMsRunReader::massSpectrumCstSPtr ( std::size_t  spectrum_index)
overridevirtual

Implements pappso::MsRunReader.

Definition at line 61 of file timsframesmsrunreader.cpp.

62{
63 return msp_timsData->getMassSpectrumCstSPtrByGlobalScanIndex(spectrum_index);
64}

References pappso::TimsMsRunReaderBase::msp_timsData.

◆ massSpectrumSPtr()

pappso::MassSpectrumSPtr TimsFramesMsRunReader::massSpectrumSPtr ( std::size_t  spectrum_index)
overridevirtual

get a MassSpectrumSPtr class given its spectrum index

Implements pappso::MsRunReader.

Definition at line 49 of file timsframesmsrunreader.cpp.

51{
53 QObject::tr("Not yet implemented in TimsFramesMsRunReader %1.\n")
54 .arg(__LINE__));
55
57}
std::shared_ptr< MassSpectrum > MassSpectrumSPtr

◆ qualifiedMassSpectrum()

QualifiedMassSpectrum TimsFramesMsRunReader::qualifiedMassSpectrum ( std::size_t  spectrum_index,
bool  want_binary_data = true 
) const
overridevirtual

get a QualifiedMassSpectrum class given its scan number

Implements pappso::MsRunReader.

Definition at line 68 of file timsframesmsrunreader.cpp.

70{
71
72 QualifiedMassSpectrum mass_spectrum;
73
74 msp_timsData->getQualifiedMassSpectrumByGlobalScanIndex(
75 getMsRunId(), mass_spectrum, spectrum_index, want_binary_data);
76 return mass_spectrum;
77}
const MsRunIdCstSPtr & getMsRunId() const
Class representing a fully specified mass spectrum.

References pappso::MsRunReader::getMsRunId(), and pappso::TimsMsRunReaderBase::msp_timsData.

◆ readSpectrumCollection()

void TimsFramesMsRunReader::readSpectrumCollection ( SpectrumCollectionHandlerInterface handler)
overridevirtual

function to visit an MsRunReader and get each Spectrum in a spectrum collection handler

Implements pappso::MsRunReader.

Definition at line 81 of file timsframesmsrunreader.cpp.

83{
84 // qDebug() << "Reading the spectrum collection with no specific
85 // configuration.";
86 MsRunReadConfig config;
87 readSpectrumCollection2(config, handler);
88}
virtual void readSpectrumCollection2(const MsRunReadConfig &config, SpectrumCollectionHandlerInterface &handler) override

References readSpectrumCollection2().

◆ readSpectrumCollection2()

void TimsFramesMsRunReader::readSpectrumCollection2 ( const MsRunReadConfig config,
SpectrumCollectionHandlerInterface handler 
)
overridevirtual

Implements pappso::MsRunReader.

Definition at line 92 of file timsframesmsrunreader.cpp.

94{
95 // qDebug().noquote() << "Reading the spectrum collection with this "
96 // "specific configuration:"
97 // << config.toString();
98
99 std::vector<std::size_t> subset_of_tims_frame_ids;
100
101
102 bool asked_ion_mobility_scan_num_range = false;
103
104 quint32 mobility_scan_num_range_begin = std::numeric_limits<quint32>::max();
105 quint32 mobility_scan_num_range_end = std::numeric_limits<quint32>::max();
106 quint32 mobility_scan_num_range_width = std::numeric_limits<quint32>::max();
107
108 double mobility_one_over_k0 = std::numeric_limits<double>::max();
109 double mobility_one_over_k0_range_begin = std::numeric_limits<double>::max();
110 double mobility_one_over_k0_range_end = std::numeric_limits<double>::max();
111
112 if(!config
113 .getParameterValue(
115 .isNull() &&
116 !config
117 .getParameterValue(
119 .isNull())
120 {
121 mobility_scan_num_range_begin =
122 config
125 .toUInt();
126 mobility_scan_num_range_end =
127 config
130 .toUInt();
131
132 // We need the range width below.
133 mobility_scan_num_range_width =
134 mobility_scan_num_range_end + 1 - mobility_scan_num_range_begin;
135
136 asked_ion_mobility_scan_num_range = true;
137
138 // Be sure to check in the frames loop below that the user might
139 // have asked for an ion mobility range but on the basis of the 1/K0 unit.
140 }
141
142 const std::vector<FrameIdDescr> &frame_id_descr_list =
143 msp_timsData->getFrameIdDescrList();
144
145 // Just for the feedback to the user.
146 std::size_t scan_count = 0;
147
148 for(auto const &frame_record : msp_timsData->getTimsFrameRecordList())
149 {
150 if(handler.shouldStop())
151 {
152 // qDebug() << "The operation was cancelled. Breaking the loop.";
154 QObject::tr("Reading timsTOF data cancelled by the user."));
155 }
156
157 if(frame_record.frame_id == 0)
158 continue;
159
160 if(!config.acceptRetentionTimeInSeconds(frame_record.frame_time))
161 continue;
162
163 std::size_t ms_level = 2;
164 if(frame_record.msms_type == 0)
165 ms_level = 1;
166
167 if(!config.acceptMsLevel(ms_level))
168 continue;
169
170 // FIXME: this might be the place where to actually get the list of
171 // precursors' m/z and charge values.
172
173 subset_of_tims_frame_ids.push_back(frame_record.frame_id);
174
175 if(mobility_scan_num_range_width != std::numeric_limits<int>::max())
176 {
177 scan_count += mobility_scan_num_range_width;
178 }
179 else
180 {
181 scan_count += frame_id_descr_list[frame_record.frame_id].m_scanCount;
182 }
183 }
184
185 // At this point, we have a subset of frame records.
186 std::size_t frame_count = subset_of_tims_frame_ids.size();
187 qDebug() << "The number of retained RT range- and MS level-matching frames : "
188 << frame_count;
189
190 // Inform the handler of the spectrum list so that it can handle feedback to
191 // the user.
192
193 // FIXME:
194 // Either we document the number of frames (because we assume we will
195 // flatten them all)...
196 handler.spectrumListHasSize(frame_count);
197 // Or we document the number of actual scans because we might not flatten
198 // all the frames.
199 // handler.spectrumListHasSize(scan_count);
200
201 // Check for m/z range selection
202 bool asked_mz_range = false;
203 double mz_range_begin = -1;
204 double mz_range_end = -1;
205
207 {
208 asked_mz_range = true;
209
210 mz_range_begin =
212 .toDouble();
213 mz_range_end =
215 .toDouble();
216
217 // qDebug() << "The m/z range asked is: " << mz_range_begin << "--"
218 // << mz_range_end;
219 }
220
221 // Check for m/z resolution downgrading
222 // The idea is that we merge a number of mz indices into a single index,
223 // which is essentially an increase of the m/z bin size, and therefore
224 // of the resolution/definition of the mass spectrum.
225 std::size_t mz_index_merge_window = 0;
226 if(!config
227 .getParameterValue(
229 .isNull())
230 {
231 mz_index_merge_window =
232 config
235 .toUInt();
236
237 // qDebug() << "mz_index_merge_window=" << mz_index_merge_window;
238 }
239
240 // The scan index is the index of the scan in the *whole* mass data file, it
241 // is a sequential number of scans over all the frames.
242 std::size_t scan_index = 0; // iterate in each spectrum
243
244 for(std::size_t tims_frame_id : subset_of_tims_frame_ids)
245 {
246 if(handler.shouldStop())
247 {
248 // qDebug() << "The operation was cancelled. Breaking the loop.";
250 QObject::tr("Reading timsTOF data cancelled by the user."));
251 }
252
253 // qDebug() << "tims_frame_id=" << tims_frame_id;
254
255 const FrameIdDescr &current_frame_record =
256 frame_id_descr_list[tims_frame_id];
257 // qDebug() << "tims_frame_id=" << tims_frame_id;
258
259 // FIXME: from an outsider point of view, cumulated size does not
260 // convey the notion of sequential scan number.
261
262 scan_index = current_frame_record.m_globalScanIndex;
263
264 TimsFrameCstSPtr tims_frame_csp =
265 msp_timsData->getTimsFrameCstSPtrCached(tims_frame_id);
266
267 // If the user wants to select 1/Ko values in a given range, we need to
268 // compute the ion mobility scan value starting from that 1/Ko value in
269 // *each* frame. Note that the computed mobility_scan_num_begin and
270 // mobility_scan_num_end would override thoses possibly set with
271 // TimsFramesMsRunReader_mobility_index_begin/end above.
272
273 if(!config
274 .getParameterValue(
276 .isNull() &&
277 !config
278 .getParameterValue(
280 .isNull())
281 {
282 mobility_one_over_k0_range_begin =
283 config
286 .toDouble();
287
288 mobility_one_over_k0_range_end =
289 config
292 .toDouble();
293
294 mobility_scan_num_range_begin =
295 tims_frame_csp.get()->getScanIndexFromOneOverK0(
296 mobility_one_over_k0_range_begin);
297
298 mobility_scan_num_range_end =
299 tims_frame_csp.get()->getScanIndexFromOneOverK0(
300 mobility_one_over_k0_range_end);
301
302 asked_ion_mobility_scan_num_range = true;
303 }
304
305 // Now that we know if the user has asked for an ion mobility range,
306 // either using scan indices or 1/K0 values, we need to double check the
307 // range borders.
308 quint32 count_of_mobility_scans = tims_frame_csp->getTotalNumberOfScans();
309
310 if(asked_ion_mobility_scan_num_range)
311 {
312 if(mobility_scan_num_range_end > (count_of_mobility_scans - 1))
313 {
314 mobility_scan_num_range_end = count_of_mobility_scans - 1;
315 }
316 }
317 else
318 {
319 mobility_scan_num_range_begin = 0;
320 mobility_scan_num_range_end = count_of_mobility_scans - 1;
321 }
322
323 // Now that we know the mobility index range, if we did not set the
324 // mobility one over K0 because that was not the unit used by
325 // the caller, then we can compute these values and set them
326 // later to the qualified mass spectrum parameters.
327 if(mobility_one_over_k0_range_begin == std::numeric_limits<double>::max())
328 mobility_one_over_k0_range_begin =
329 tims_frame_csp->getOneOverK0Transformation(
330 mobility_scan_num_range_begin);
331 if(mobility_one_over_k0_range_end == std::numeric_limits<double>::max())
332 mobility_one_over_k0_range_end =
333 tims_frame_csp->getOneOverK0Transformation(
334 mobility_scan_num_range_end);
335
336 mobility_scan_num_range_width =
337 mobility_scan_num_range_end + 1 - mobility_scan_num_range_begin;
338
339 // We want to provide the inverse mobility for the scan that sits in the
340 // middle of the defined range or the whole range if none is defined..
341 mobility_one_over_k0 = tims_frame_csp.get()->getScanIndexFromOneOverK0(
342 mobility_scan_num_range_begin + (mobility_scan_num_range_width / 2));
343
344 // Now, with or without the peak list, we have to craft a qualified mass
345 // spectrum that will hold all the data about the data in it.
346 QualifiedMassSpectrum qualified_mass_spectrum;
347
348 MassSpectrumId spectrum_id;
349
350 spectrum_id.setSpectrumIndex(tims_frame_id);
351 spectrum_id.setMsRunId(getMsRunId());
352
353 // Can be modified to add bits that might help our case
354 spectrum_id.setNativeId(
355 QString("frame_id=%1 global_scan_index=%2 im_scan_range_begin=%3 "
356 "im_scan_range_end=%4")
357 .arg(tims_frame_id)
358 .arg(scan_index)
359 .arg(mobility_scan_num_range_begin)
360 .arg(mobility_scan_num_range_end));
361
362 qualified_mass_spectrum.setMassSpectrumId(spectrum_id);
363
364 // We want to document the retention time!
365
366 qualified_mass_spectrum.setRtInSeconds(
367 tims_frame_csp.get()->getRtInSeconds());
368
369 // We do want to document the ms level of the spectrum and possibly
370 // the precursor's m/z and charge.
371 unsigned int frame_ms_level = tims_frame_csp.get()->getMsLevel();
372 qualified_mass_spectrum.setMsLevel(frame_ms_level);
373
374
375 // Arrival time at half the range.
376
377 qualified_mass_spectrum.setDtInMilliSeconds(
378 tims_frame_csp.get()->getDriftTimeInMilliseconds(
379 mobility_scan_num_range_begin + (mobility_scan_num_range_width / 2)));
380
381 // 1/K0
382 qDebug() << "mobility_one_over_k0:" << mobility_one_over_k0
383 << "mobility_one_over_k0_range_begin:"
384 << mobility_one_over_k0_range_begin
385 << "mobility_one_over_k0_range_end"
386 << mobility_one_over_k0_range_end;
387
388 if(mobility_one_over_k0 == std::numeric_limits<double>::max() ||
389 mobility_one_over_k0_range_begin ==
390 std::numeric_limits<double>::max() ||
391 mobility_one_over_k0_range_end == std::numeric_limits<double>::max())
392 throw(
393 ExceptionNotPossible("Not possible that mobility_one_over_k0 and its "
394 "range are undefined."));
395
396 qualified_mass_spectrum.setParameterValue(
398 qualified_mass_spectrum.setParameterValue(
400 mobility_one_over_k0_range_begin);
401 qualified_mass_spectrum.setParameterValue(
403 mobility_one_over_k0_range_end);
404
405 // qDebug() << "mobility_scan_num_range_begin:"
406 // << mobility_scan_num_range_begin
407 // << "mobility_scan_num_range_end:" <<
408 // mobility_scan_num_range_end;
409
410 if(mobility_scan_num_range_begin == std::numeric_limits<quint32>::max() ||
411 mobility_scan_num_range_end == std::numeric_limits<quint32>::max())
413 "Not possible that mobility_scan_num_range values are undefined."));
414
415 qualified_mass_spectrum.setParameterValue(
417 mobility_scan_num_range_begin + (mobility_scan_num_range_width / 2));
418 qualified_mass_spectrum.setParameterValue(
420 mobility_scan_num_range_begin);
421 qualified_mass_spectrum.setParameterValue(
423 mobility_scan_num_range_end);
424
425 qualified_mass_spectrum.setParameterValue(
427 static_cast<qlonglong>(tims_frame_csp->getTotalNumberOfScans()));
428
429
430 Trace trace;
431
432 if(config.needPeakList())
433 {
434 // Provide these two variables for the function below to fill in the
435 // values. We will need them later.
436 quint32 min_mz_index_out = 0;
437 quint32 max_mz_index_out = 0;
438
439 if(asked_mz_range)
440 {
441 trace =
442 tims_frame_csp->combineScansToTraceWithDowngradedMzResolution2(
443 mz_index_merge_window,
444 mz_range_begin,
445 mz_range_end,
446 mobility_scan_num_range_begin,
447 mobility_scan_num_range_end,
448 min_mz_index_out,
449 max_mz_index_out);
450 }
451 else
452 {
453 trace =
454 tims_frame_csp->combineScansToTraceWithDowngradedMzResolution(
455 mz_index_merge_window,
456 mobility_scan_num_range_begin,
457 mobility_scan_num_range_end,
458 min_mz_index_out,
459 max_mz_index_out);
460 }
461
462 // qDebug() << "Got min_mz_index_out:" << min_mz_index_out;
463 // qDebug() << "Got max_mz_index_out:" << max_mz_index_out;
464
465 qualified_mass_spectrum.setParameterValue(
467 min_mz_index_out);
468 qualified_mass_spectrum.setParameterValue(
470 max_mz_index_out);
471
472 qualified_mass_spectrum.setMassSpectrumSPtr(
473 std::make_shared<MassSpectrum>(trace));
474 qualified_mass_spectrum.setEmptyMassSpectrum(false);
475 }
476 else
477 {
478 qualified_mass_spectrum.setEmptyMassSpectrum(true);
479 }
480
481 handler.setQualifiedMassSpectrum(qualified_mass_spectrum);
482 }
483}
void setNativeId(const QString &native_id)
void setMsRunId(MsRunIdCstSPtr other)
void setSpectrumIndex(std::size_t index)
const QVariant getParameterValue(MsRunReadConfigParameter parameter) const
bool acceptMsLevel(std::size_t ms_level) const
bool acceptRetentionTimeInSeconds(double retention_time_in_seconds) const
void setDtInMilliSeconds(pappso_double rt)
Set the drift time in milliseconds.
void setMassSpectrumId(const MassSpectrumId &iD)
Set the MassSpectrumId.
void setMsLevel(uint ms_level)
Set the mass spectrum level.
void setParameterValue(QualifiedMassSpectrumParameter parameter, const QVariant &value)
void setMassSpectrumSPtr(MassSpectrumSPtr massSpectrum)
Set the MassSpectrumSPtr.
void setRtInSeconds(pappso_double rt)
Set the retention time in seconds.
void setEmptyMassSpectrum(bool is_empty_mass_spectrum)
virtual void setQualifiedMassSpectrum(const QualifiedMassSpectrum &spectrum)=0
@ TimsFrameMzIndexBegin
Bruker's timsTOF mz index frame start range.
@ IonMobOneOverK0Begin
1/K0 range's begin value
@ IonMobOneOverK0End
1/K0 range's end value
@ TimsFrameScansCount
Bruker's timsTOF frame's total ion mobility slots.
@ TimsFrameMzIndexEnd
Bruker's timsTOF mz index frame end range.
std::size_t m_globalScanIndex
Definition timsdata.h:63

References pappso::MsRunReadConfig::acceptMsLevel(), pappso::MsRunReadConfig::acceptRetentionTimeInSeconds(), pappso::MsRunReader::getMsRunId(), pappso::MsRunReadConfig::getParameterValue(), pappso::IonMobOneOverK0, pappso::IonMobOneOverK0Begin, pappso::IonMobOneOverK0End, pappso::FrameIdDescr::m_globalScanIndex, pappso::TimsMsRunReaderBase::msp_timsData, pappso::MzRangeBegin, pappso::MzRangeEnd, pappso::MsRunReadConfig::needPeakList(), pappso::QualifiedMassSpectrum::setDtInMilliSeconds(), pappso::QualifiedMassSpectrum::setEmptyMassSpectrum(), pappso::QualifiedMassSpectrum::setMassSpectrumId(), pappso::QualifiedMassSpectrum::setMassSpectrumSPtr(), pappso::QualifiedMassSpectrum::setMsLevel(), pappso::MassSpectrumId::setMsRunId(), pappso::MassSpectrumId::setNativeId(), pappso::QualifiedMassSpectrum::setParameterValue(), pappso::SpectrumCollectionHandlerInterface::setQualifiedMassSpectrum(), pappso::QualifiedMassSpectrum::setRtInSeconds(), pappso::MassSpectrumId::setSpectrumIndex(), pappso::SpectrumCollectionHandlerInterface::shouldStop(), pappso::SpectrumCollectionHandlerInterface::spectrumListHasSize(), pappso::TimsFrameIonMobOneOverK0Begin, pappso::TimsFrameIonMobOneOverK0End, pappso::TimsFrameIonMobScanIndexBegin, pappso::TimsFrameIonMobScanIndexEnd, pappso::TimsFrameMzIndexBegin, pappso::TimsFrameMzIndexEnd, pappso::TimsFrameMzIndexMergeWindow, pappso::TimsFrameScansCount, and pappso::TimsIonMobScanIndex.

Referenced by readSpectrumCollection().

◆ readSpectrumCollectionByMsLevel()

void TimsFramesMsRunReader::readSpectrumCollectionByMsLevel ( SpectrumCollectionHandlerInterface handler,
unsigned int  ms_level 
)
overridevirtual

function to visit an MsRunReader and get each Spectrum in a spectrum collection handler by Ms Levels

Implements pappso::MsRunReader.

Definition at line 487 of file timsframesmsrunreader.cpp.

490{
491 qDebug();
492}

◆ spectrumListSize()

std::size_t TimsFramesMsRunReader::spectrumListSize ( ) const
overridevirtual

get the totat number of spectrum conained in the MSrun data file

Implements pappso::MsRunReader.

Definition at line 496 of file timsframesmsrunreader.cpp.

497{
498 return msp_timsData->getTotalScanCount();
499}

References pappso::TimsMsRunReaderBase::msp_timsData.

Friends And Related Symbol Documentation

◆ MsFileAccessor

friend class MsFileAccessor
friend

Definition at line 44 of file timsframesmsrunreader.h.


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