libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
qualifiedmassspectrum.cpp
Go to the documentation of this file.
1/*******************************************************************************
2 * Copyright (c) 2015 Olivier Langella <olivier.langella@u-psud.fr>.
3 *
4 * This file is part of the PAPPSOms++ library.
5 *
6 * PAPPSOms++ is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * PAPPSOms++ is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with PAPPSOms++. If not, see <http://www.gnu.org/licenses/>.
18 *
19 ******************************************************************************/
20
21/////////////////////// StdLib includes
22#include <cmath>
23
24
25/////////////////////// Qt includes
26#include <QDebug>
27
28
29/////////////////////// Local includes
31#include "../utils.h"
32#include "../pappsoexception.h"
33
34
35namespace pappso
36{
37
38//! Construct an uninitialized QualifiedMassSpectrum.
42
43
44//! Construct a QualifiedMassSpectrum using a MassSpectrumId;
46 : m_massSpectrumId(id)
47{
48}
49
50
52 MassSpectrumSPtr mass_spectrum_SPtr)
53 : msp_massSpectrum{mass_spectrum_SPtr}
54{
55}
56
57
58//! Construct a QualifiedMassSpectrum as a copy of \p other.
60 : msp_massSpectrum(other.msp_massSpectrum),
61 m_massSpectrumId(other.m_massSpectrumId),
62 m_isEmptyMassSpectrum(other.m_isEmptyMassSpectrum),
63 m_msLevel(other.m_msLevel),
64 m_rt(other.m_rt),
65 m_dt(other.m_dt),
66 m_precursorSpectrumIndex(other.m_precursorSpectrumIndex),
67 m_precursorNativeId(other.m_precursorNativeId),
68 m_precursorIonData(other.m_precursorIonData),
69 m_paramsMap(other.m_paramsMap)
70{
71 // qDebug();
72}
73
74
75//! Destruct this QualifiedMassSpectrum.
77{
78 // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << " ()";
79}
80
81
98
99
102{
103 this->msp_massSpectrum =
104 std::make_shared<MassSpectrum>(*this->msp_massSpectrum.get());
105 return *this;
106}
107
108
111{
112 return std::make_shared<QualifiedMassSpectrum>(*this);
113}
114
115
118{
119 return std::make_shared<const QualifiedMassSpectrum>(*this);
120}
121
122
123//! Set the MassSpectrumSPtr.
124void
129
130
131//! Get the MassSpectrumSPtr.
137
138
139//! Get the MassSpectrumCstSPtr.
145
146
147//! Set the MassSpectrumId.
148void
153
154
155//! Get the MassSpectrumId.
156const MassSpectrumId &
161
167
168void
170{
171 m_isEmptyMassSpectrum = is_empty_mass_spectrum;
172}
173
174
175bool
180
181
182//! Set the mass spectrum level.
183void
185{
186 m_msLevel = level;
187}
188
189
190//! Get the mass spectrum level.
191unsigned int
193{
194 return m_msLevel;
195}
196
197
198//! Set the retention time in seconds.
199void
201{
202 m_rt = rt_in_seconds;
203}
204
205
206//! Get the retention time in seconds.
209{
210 return m_rt;
211}
212
213
214//! Get the retention time in minutes.
217{
218 return m_rt / 60;
219}
220
221
222//! Set the drift time in milliseconds.
223void
225{
226 if(std::isinf(dt_in_milli_seconds))
227 m_dt = -1;
228 else
229 m_dt = dt_in_milli_seconds;
230}
231
232
233//! Get the drift time in milliseconds.
239
240
241//! Get the precursor m/z ratio.
244{
245 if(!m_precursorIonData.size())
246 {
247 if(ok_p != nullptr)
248 *ok_p = false;
249
250 return std::numeric_limits<double>::max();
251 }
252
253 if(ok_p != nullptr)
254 *ok_p = true;
255
256 // qDebug() << "Returning precursor mz value: " <<
257 // m_precursorIonData.front().mz;
258 return m_precursorIonData.front().mz;
259}
260
261//! Get the precursor mass ratio.
262double
264{
265 if(ok_p != nullptr)
266 *ok_p = false;
267 bool ok_precmz = false;
268 double mz_prec = getPrecursorMz(&ok_precmz);
269 if(ok_precmz)
270 {
271 uint charge = getPrecursorCharge(&ok_precmz);
272 if(ok_precmz)
273 {
274 // compute precursor mass given the charge state
275 mz_prec = mz_prec * (double)charge;
276 mz_prec -= (MHPLUS * (double)charge);
277 if(ok_p != nullptr)
278 *ok_p = true;
279 return mz_prec;
280 }
281 }
282 return std::numeric_limits<double>::max();
283}
284
285QString
287 const std::vector<PrecursorIonData> &precursor_ion_data_vector,
288 const QString &separator) const
289{
290 QString text;
291
292 // We do not want to use the separator if there is only one precursor in the
293 // vector.
294
295 if(precursor_ion_data_vector.size() == 1)
296 return QString("%1").arg(precursor_ion_data_vector.front().mz, 0, 'f', 6);
297
298 // If there are more than one precursor, then we should list them joined with
299 // the separator.
300
301 using iterator = std::vector<pappso::PrecursorIonData>::const_iterator;
302
303 iterator begin_iterator = precursor_ion_data_vector.begin();
304 iterator pre_end_iterator = std::prev(precursor_ion_data_vector.end());
305
306 for(; begin_iterator != precursor_ion_data_vector.end(); ++begin_iterator)
307 {
308 if(begin_iterator == pre_end_iterator)
309 // No separator at the end of the string
310 text += QString("%1").arg(begin_iterator->mz, 0, 'f', 6);
311 else
312 text +=
313 QString("%1%2").arg(begin_iterator->mz, 0, 'f', 6).arg(separator);
314 }
315
316 return text;
317}
318
319
320QString
322 const QString &separator) const
323{
325}
326
327
328QString
330 const QString &separator) const
331{
332 // Sort the PrecursorIonData instances by increasing mz values.
333 // Then craft the string using the mz values.
334
335 std::vector<PrecursorIonData> sorted_vector =
337
338 return getPrecursorDataMzValuesAsString(sorted_vector, separator);
339}
340
341
342//! Get the precursor charge.
343unsigned int
345{
346 if(!m_precursorIonData.size())
347 {
348 if(ok_p != nullptr)
349 *ok_p = false;
350 return std::numeric_limits<unsigned int>::max();
351 }
352
353 if(ok_p != nullptr)
354 *ok_p = true;
355
356 return m_precursorIonData.front().charge;
357}
358
359
360QString
362 const std::vector<PrecursorIonData> &precursor_ion_data_vector,
363 const QString &separator) const
364{
365 QString text;
366
367 // We do not want to use the separator if there is only one precursor in the
368 // vector.
369
370 if(precursor_ion_data_vector.size() == 1)
371 return QString("%1").arg(precursor_ion_data_vector.front().charge);
372
373 // If there are more than one precursor, then we should list them joined with
374 // the separator.
375 for(auto item : precursor_ion_data_vector)
376 {
377 text += QString("%1%2").arg(item.charge).arg(separator);
378 }
379
380 return text;
381}
382
383
384QString
390
391
392QString
394 const QString &separator) const
395{
396 // Sort the PrecursorIonData instances by increasing mz values.
397 // Then craft the string using the mz values.
398
399 std::vector<PrecursorIonData> sorted_vector =
401
402 return getPrecursorDataChargeValuesAsString(sorted_vector, separator);
403}
404
405
406//! Get the intensity of the precursor ion.
409{
410 if(!m_precursorIonData.size())
411 {
412 if(ok_p != nullptr)
413 *ok_p = false;
414 return std::numeric_limits<double>::max();
415 }
416
417 if(ok_p != nullptr)
418 *ok_p = true;
419
420 return m_precursorIonData.front().intensity;
421}
422
423
424//! Set the scan number of the precursor ion.
425void
427 std::size_t precursor_spectrum_index)
428{
429 m_precursorSpectrumIndex = precursor_spectrum_index;
430}
431
432
433//! Get the scan number of the precursor ion.
434std::size_t
439
440
441//! Set the scan native id of the precursor ion.
442void
444{
445 m_precursorNativeId = native_id;
446}
447
448const QString &
453
454
455void
457 const PrecursorIonData &precursor_ion_data)
458{
459 m_precursorIonData.push_back(precursor_ion_data);
460}
461
462
463const std::vector<PrecursorIonData> &
468
469
470std::vector<PrecursorIonData>
472{
473 std::vector<PrecursorIonData> new_vector;
474 new_vector.assign(m_precursorIonData.begin(), m_precursorIonData.end());
475
476 std::sort(new_vector.begin(),
477 new_vector.end(),
478 [](const PrecursorIonData &a, const PrecursorIonData &b) -> bool {
479 return a.mz < b.mz;
480 });
481
482 return new_vector;
483}
484
485
486void
488 QualifiedMassSpectrumParameter parameter, const QVariant &value)
489{
490
491 auto ret = m_paramsMap.insert(
492 std::pair<QualifiedMassSpectrumParameter, QVariant>(parameter, value));
493
494 if(ret.second == false)
495 {
496 ret.first->second = value;
497 }
498}
499
500
501const QVariant
503 QualifiedMassSpectrumParameter parameter) const
504{
505 auto it = m_paramsMap.find(parameter);
506 if(it == m_paramsMap.end())
507 {
508 return QVariant();
509 }
510 else
511 {
512 return it->second;
513 }
514}
515
516
517std::size_t
519{
520 if(msp_massSpectrum == nullptr)
521 {
522 throw pappso::PappsoException(QObject::tr("msp_massSpectrum == nullptr"));
523 }
524 return msp_massSpectrum.get()->size();
525}
526
527
528QString
530{
531 QString text;
532
533 if(msp_massSpectrum != nullptr && msp_massSpectrum.get() != nullptr)
534 {
535 QString pointer_string =
536 QString("msp_massSpectrum.get(): %1 ")
537 .arg(Utils::pointerToString((void *)msp_massSpectrum.get()));
538
539 text += pointer_string;
540 }
541 else
542 text += QString("msp_massSpectrum is nullptr ");
543
544 // qDebug() << text;
545
546 QString precursor_mz_values_string;
547
548 if(m_precursorIonData.size())
549 precursor_mz_values_string += "Precursor mz values: ";
550
551 precursor_mz_values_string += getMzSortedPrecursorDataMzValuesAsString();
552
553 precursor_mz_values_string += "\n";
554
555 text +=
556 QString(
557 "; m_massSpectrumId : %1 \n"
558 "m_msLevel: %2 ; m_rt (min): %3 ; m_dt (ms): %4 ; prec. spec. "
559 "index: %5 ; %6")
561 .arg(m_msLevel)
562 .arg(getRtInMinutes(), 0, 'f', 2)
563 .arg(m_dt, 0, 'f', 5)
564 .arg(m_precursorSpectrumIndex != std::numeric_limits<std::size_t>::max()
566 : -1)
567 .arg(precursor_mz_values_string);
568
569 if(with_data)
570 {
571 text += msp_massSpectrum->toString();
572 }
573
574 return text;
575}
576
577
578} // namespace pappso
Class representing a fully specified mass spectrum.
uint getMsLevel() const
Get the mass spectrum level.
QualifiedMassSpectrum & operator=(const QualifiedMassSpectrum &other)
MassSpectrumCstSPtr getMassSpectrumCstSPtr() const
Get the MassSpectrumCstSPtr.
std::vector< PrecursorIonData > m_precursorIonData
std::vector< PrecursorIonData > getPrecursorIonDataSortedWithMz() const
void setPrecursorNativeId(const QString &native_id)
Set the scan native id of the precursor ion.
std::size_t m_precursorSpectrumIndex
Index of the spectrum of the precusor ion that was fragmented to yield.
pappso_double getDtInMilliSeconds() const
Get the drift time in milliseconds.
const std::vector< PrecursorIonData > & getPrecursorIonData() const
uint getPrecursorCharge(bool *ok=nullptr) const
get precursor charge
pappso_double getRtInMinutes() const
Get the retention time in minutes.
unsigned int m_msLevel
Mass spectrometry level of this mass spectrum.
void setDtInMilliSeconds(pappso_double rt)
Set the drift time in milliseconds.
~QualifiedMassSpectrum()
Destruct this QualifiedMassSpectrum.
const QString & getPrecursorNativeId() const
pappso_double m_rt
Retention time (in seconds) at which this mass spectrum was acquired.
pappso_double m_dt
Drift time (in milliseconds) at which this mass spectrum was acquired.
pappso_double getPrecursorIntensity(bool *ok=nullptr) const
get precursor intensity
double getPrecursorMass(bool *ok_p=nullptr) const
get precursor mass given the charge stats and precursor mz
QString toString(bool with_data=false) const
void appendPrecursorIonData(const PrecursorIonData &precursor_ion_data)
std::map< QualifiedMassSpectrumParameter, QVariant > m_paramsMap
map containing any parameter value for this spectrum
MassSpectrumSPtr msp_massSpectrum
Shared pointer to the mass spectrum.
const MassSpectrumId & getMassSpectrumId() const
Get the MassSpectrumId.
QString getPrecursorDataChargeValuesAsString(const std::vector< PrecursorIonData > &precursor_ion_data_vector, const QString &separator="\n") const
void setMassSpectrumId(const MassSpectrumId &iD)
Set the MassSpectrumId.
void setMsLevel(uint ms_level)
Set the mass spectrum level.
void setPrecursorSpectrumIndex(std::size_t precursor_scan_num)
Set the scan number of the precursor ion.
QString getPrecursorDataMzValuesAsString(const std::vector< PrecursorIonData > &precursor_ion_data_vector, const QString &separator="\n") const
QualifiedMassSpectrumCstSPtr makeQualifiedMassSpectrumCstSPtr() const
pappso_double getPrecursorMz(bool *ok=nullptr) const
get precursor mz
const QualifiedMassSpectrum & cloneMassSpectrumSPtr()
clone the mass spectrum contained in Qualified Mass Spectrum
QString getMzSortedPrecursorDataMzValuesAsString(const QString &separator="\n") const
MassSpectrumSPtr getMassSpectrumSPtr() const
Get the MassSpectrumSPtr.
QString getMzSortedPrecursorDataChargeValuesAsString(const QString &separator="\n") const
QString m_precursorNativeId
Native XML id of the spectrum relative to the mz data native file.
QualifiedMassSpectrumSPtr makeQualifiedMassSpectrumSPtr() const
MassSpectrumId m_massSpectrumId
Id of the mass spectrum.
void setParameterValue(QualifiedMassSpectrumParameter parameter, const QVariant &value)
QualifiedMassSpectrum()
Construct an uninitialized QualifiedMassSpectrum.
void setMassSpectrumSPtr(MassSpectrumSPtr massSpectrum)
Set the MassSpectrumSPtr.
std::size_t getPrecursorSpectrumIndex() const
Get the scan number of the precursor ion.
void setRtInSeconds(pappso_double rt)
Set the retention time in seconds.
pappso_double getRtInSeconds() const
Get the retention time in seconds.
void setEmptyMassSpectrum(bool is_empty_mass_spectrum)
const QVariant getParameterValue(QualifiedMassSpectrumParameter parameter) const
static QString pointerToString(const void *const pointer)
Definition utils.cpp:295
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
std::shared_ptr< QualifiedMassSpectrum > QualifiedMassSpectrumSPtr
const pappso_double MHPLUS(1.007276466879)
double pappso_double
A type definition for doubles.
Definition types.h:50
std::shared_ptr< const QualifiedMassSpectrum > QualifiedMassSpectrumCstSPtr
std::shared_ptr< const MassSpectrum > MassSpectrumCstSPtr
unsigned int uint
Definition types.h:57
std::shared_ptr< MassSpectrum > MassSpectrumSPtr