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
162
163void
165{
166 m_isEmptyMassSpectrum = is_empty_mass_spectrum;
167}
168
169
170bool
175
176
177//! Set the mass spectrum level.
178void
180{
181 m_msLevel = level;
182}
183
184
185//! Get the mass spectrum level.
186unsigned int
188{
189 return m_msLevel;
190}
191
192
193//! Set the retention time in seconds.
194void
196{
197 m_rt = rt_in_seconds;
198}
199
200
201//! Get the retention time in seconds.
204{
205 return m_rt;
206}
207
208
209//! Get the retention time in minutes.
212{
213 return m_rt / 60;
214}
215
216
217//! Set the drift time in milliseconds.
218void
220{
221 if(std::isinf(dt_in_milli_seconds))
222 m_dt = -1;
223 else
224 m_dt = dt_in_milli_seconds;
225}
226
227
228//! Get the drift time in milliseconds.
234
235
236//! Get the precursor m/z ratio.
239{
240 if(!m_precursorIonData.size())
241 {
242 if(ok_p != nullptr)
243 *ok_p = false;
244
245 return std::numeric_limits<double>::max();
246 }
247
248 if(ok_p != nullptr)
249 *ok_p = true;
250
251 // qDebug() << "Returning precursor mz value: " <<
252 // m_precursorIonData.front().mz;
253 return m_precursorIonData.front().mz;
254}
255
256//! Get the precursor mass ratio.
257double
259{
260 if(ok_p != nullptr)
261 *ok_p = false;
262 bool ok_precmz = false;
263 double mz_prec = getPrecursorMz(&ok_precmz);
264 if(ok_precmz)
265 {
266 uint charge = getPrecursorCharge(&ok_precmz);
267 if(ok_precmz)
268 {
269 // compute precursor mass given the charge state
270 mz_prec = mz_prec * (double)charge;
271 mz_prec -= MHPLUS * (double)charge;
272 if(ok_p != nullptr)
273 *ok_p = true;
274 return mz_prec;
275 }
276 }
277 return std::numeric_limits<double>::max();
278}
279
280QString
282 const std::vector<PrecursorIonData> &precursor_ion_data_vector,
283 const QString &separator) const
284{
285 QString text;
286
287 // We do not want to use the separator if there is only one precursor in the
288 // vector.
289
290 if(precursor_ion_data_vector.size() == 1)
291 return QString("%1").arg(precursor_ion_data_vector.front().mz, 0, 'f', 6);
292
293 // If there are more than one precursor, then we should list them joined with
294 // the separator.
295
296 using iterator = std::vector<pappso::PrecursorIonData>::const_iterator;
297
298 iterator begin_iterator = precursor_ion_data_vector.begin();
299 iterator pre_end_iterator = std::prev(precursor_ion_data_vector.end());
300
301 for(; begin_iterator != precursor_ion_data_vector.end(); ++begin_iterator)
302 {
303 if(begin_iterator == pre_end_iterator)
304 // No separator at the end of the string
305 text += QString("%1").arg(begin_iterator->mz, 0, 'f', 6);
306 else
307 text +=
308 QString("%1%2").arg(begin_iterator->mz, 0, 'f', 6).arg(separator);
309 }
310
311 return text;
312}
313
314
315QString
317 const QString &separator) const
318{
320}
321
322
323QString
325 const QString &separator) const
326{
327 // Sort the PrecursorIonData instances by increasing mz values.
328 // Then craft the string using the mz values.
329
330 std::vector<PrecursorIonData> sorted_vector =
332
333 return getPrecursorDataMzValuesAsString(sorted_vector, separator);
334}
335
336
337//! Get the precursor charge.
338unsigned int
340{
341 if(!m_precursorIonData.size())
342 {
343 if(ok_p != nullptr)
344 *ok_p = false;
345 return std::numeric_limits<unsigned int>::max();
346 }
347
348 if(ok_p != nullptr)
349 *ok_p = true;
350
351 return m_precursorIonData.front().charge;
352}
353
354
355QString
357 const std::vector<PrecursorIonData> &precursor_ion_data_vector,
358 const QString &separator) const
359{
360 QString text;
361
362 // We do not want to use the separator if there is only one precursor in the
363 // vector.
364
365 if(precursor_ion_data_vector.size() == 1)
366 return QString("%1").arg(precursor_ion_data_vector.front().charge);
367
368 // If there are more than one precursor, then we should list them joined with
369 // the separator.
370 for(auto item : precursor_ion_data_vector)
371 {
372 text += QString("%1%2").arg(item.charge).arg(separator);
373 }
374
375 return text;
376}
377
378
379QString
385
386
387QString
389 const QString &separator) const
390{
391 // Sort the PrecursorIonData instances by increasing mz values.
392 // Then craft the string using the mz values.
393
394 std::vector<PrecursorIonData> sorted_vector =
396
397 return getPrecursorDataChargeValuesAsString(sorted_vector, separator);
398}
399
400
401//! Get the intensity of the precursor ion.
404{
405 if(!m_precursorIonData.size())
406 {
407 if(ok_p != nullptr)
408 *ok_p = false;
409 return std::numeric_limits<double>::max();
410 }
411
412 if(ok_p != nullptr)
413 *ok_p = true;
414
415 return m_precursorIonData.front().intensity;
416}
417
418
419//! Set the scan number of the precursor ion.
420void
422 std::size_t precursor_spectrum_index)
423{
424 m_precursorSpectrumIndex = precursor_spectrum_index;
425}
426
427
428//! Get the scan number of the precursor ion.
429std::size_t
434
435
436//! Set the scan native id of the precursor ion.
437void
439{
440 m_precursorNativeId = native_id;
441}
442
443const QString &
448
449
450void
452 const PrecursorIonData &precursor_ion_data)
453{
454 m_precursorIonData.push_back(precursor_ion_data);
455}
456
457
458const std::vector<PrecursorIonData> &
463
464
465std::vector<PrecursorIonData>
467{
468 std::vector<PrecursorIonData> new_vector;
469 new_vector.assign(m_precursorIonData.begin(), m_precursorIonData.end());
470
471 std::sort(new_vector.begin(),
472 new_vector.end(),
473 [](const PrecursorIonData &a, const PrecursorIonData &b) -> bool {
474 return a.mz < b.mz;
475 });
476
477 return new_vector;
478}
479
480
481void
483 QualifiedMassSpectrumParameter parameter, const QVariant &value)
484{
485
486 auto ret = m_paramsMap.insert(
487 std::pair<QualifiedMassSpectrumParameter, QVariant>(parameter, value));
488
489 if(ret.second == false)
490 {
491 ret.first->second = value;
492 }
493}
494
495
496const QVariant
498 QualifiedMassSpectrumParameter parameter) const
499{
500 auto it = m_paramsMap.find(parameter);
501 if(it == m_paramsMap.end())
502 {
503 return QVariant();
504 }
505 else
506 {
507 return it->second;
508 }
509}
510
511
512std::size_t
514{
515 if(msp_massSpectrum == nullptr)
516 {
517 throw pappso::PappsoException(QObject::tr("msp_massSpectrum == nullptr"));
518 }
519 return msp_massSpectrum.get()->size();
520}
521
522
523QString
525{
526 QString text;
527
528 if(msp_massSpectrum != nullptr && msp_massSpectrum.get() != nullptr)
529 {
530 QString pointer_string =
531 QString("msp_massSpectrum.get(): %1 ")
532 .arg(Utils::pointerToString((void *)msp_massSpectrum.get()));
533
534 text += pointer_string;
535 }
536 else
537 text += QString("msp_massSpectrum is nullptr ");
538
539 // qDebug() << text;
540
541 QString precursor_mz_values_string;
542
543 if(m_precursorIonData.size())
544 precursor_mz_values_string += "Precursor mz values: ";
545
546 precursor_mz_values_string += getMzSortedPrecursorDataMzValuesAsString();
547
548 precursor_mz_values_string += "\n";
549
550 text +=
551 QString(
552 "; m_massSpectrumId : %1 \n"
553 "m_msLevel: %2 ; m_rt (min): %3 ; m_dt (ms): %4 ; prec. spec. "
554 "index: %5 ; %6")
556 .arg(m_msLevel)
557 .arg(getRtInMinutes(), 0, 'f', 2)
558 .arg(m_dt, 0, 'f', 5)
559 .arg(m_precursorSpectrumIndex != std::numeric_limits<std::size_t>::max()
561 : -1)
562 .arg(precursor_mz_values_string);
563
564 if(with_data)
565 {
566 text += msp_massSpectrum->toString();
567 }
568
569 return text;
570}
571
572
573} // 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:251
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