GCC Code Coverage Report


source/XpertMassCore/src/
File: source/XpertMassCore/src/MassPeakShaperConfig.cpp
Date: 2025-11-19 15:26:11
Lines:
0/265
0.0%
Functions:
0/39
0.0%
Branches:
0/153
0.0%

Line Branch Exec Source
1 /* BEGIN software license
2 *
3 * MsXpertSuite - mass spectrometry software suite
4 * -----------------------------------------------
5 * Copyright (C) 2009--2020 Filippo Rusconi
6 *
7 * http://www.msxpertsuite.org
8 *
9 * This file is part of the MsXpertSuite project.
10 *
11 * The MsXpertSuite project is the successor of the massXpert project. This
12 * project now includes various independent modules:
13 *
14 * - massXpert, model polymer chemistries and simulate mass spectrometric data;
15 * - mineXpert, a powerful TIC chromatogram/mass spectrum viewer/miner;
16 *
17 * This program is free software: you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation, either version 3 of the License, or
20 * (at your option) any later version.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
26 *
27 * You should have received a copy of the GNU General Public License
28 * along with this program. If not, see <http://www.gnu.org/licenses/>.
29 *
30 * END software license
31 */
32
33
34 /////////////////////// StdLib includes
35 #include <cmath>
36
37
38 /////////////////////// Qt includes
39 #include <QDebug>
40
41
42 /////////////////////// pappsomspp includes
43
44
45 /////////////////////// Local includes
46 #include "MsXpS/libXpertMassCore/MassPeakShaperConfig.hpp"
47
48 namespace MsXpS
49 {
50 namespace libXpertMassCore
51 {
52
53
54 /*!
55 \variable MsXpS::libXpertMassCore::FWHM_PEAK_SPAN_FACTOR
56
57 \brief The compounding factor to account for when shaping the sides of the
58 peak.
59
60 The shape of the peak needs to reflect a real mass peak. In particular,
61 the shape of the peak has to return, \e{on each one of both sides}, to the
62 baseline, thus mimicking the baseline for a m/z distance equivalent to
63 FWHM_PEAK_SPAN_FACTOR times the FWHM m/z range from left to right. That means
64 that the simulated peak region at the left hand side of the centroid value will
65 span (FWHM_PEAK_SPAN_FACTOR/2) times the FWHM and the same one right.
66 Empirically, a good FWHM_PEAK_SPAN_FACTOR is \c 4, meaning that the left half
67 of the peak (that is centered on the centroid) will have a size corresponding
68 to two times the FHWM, and the same for the right half of the peak.
69
70 This is best exemplified as follows:
71
72 \code
73 Centroid value
74 ^
75 |
76 [ m/z - (2 * FWHM) <-|-> m/z + (2 * FWHM) ]
77 <----- width of the whole peak shape ----->
78 \endcode
79 */
80
81 int FWHM_PEAK_SPAN_FACTOR = 4;
82
83 /*!
84 \class MsXpS::libXpertMassCore::MassPeakShaperConfig
85 \inmodule libXpertMassCore
86 \ingroup XpertMassCoreMassCalculations
87 \inheaderfile MassPeakShaperConfig.hpp
88
89 \brief The MassPeakShaperConfig class provides the features required to
90 configure the shaping of a mass peak centroid into a Gaussian or a Lorentzian
91 fully profiled shape.
92
93 \e{Shaping a peak} means creating a shape around a centroid m/z value such that
94 the m/z peak is represented like it appears in a mass spectrum displayed in
95 "profile" mode.
96
97 \details{The peak shaping process}
98
99 The model used to craft the "profiled" mass peak can be of two types:
100
101 \list
102 \li \l{https://en.wikipedia.org/wiki/Gaussian_function}{Gaussian}
103 \li \l{https://en.wikipedia.org/wiki/Cauchy_distribution}{Lorentzian}
104 \endlist
105
106 The starting parameters are the (m/z,intensity) values of the peak centroid and
107 the full width at half maximum (FWHM) value that will govern the width of the
108 shape at 50% height of the peak. The width of the peak will be an inverse
109 representation of the resolving power of the instrument: the instrument with
110 the greatest resolving power will yield mass peaks with the smallest width.
111 Conversely, a very old instrument will produce mass spectra where the peaks
112 will be broad.
113
114 There are thus two possiblities for configuring the peak shape:
115
116 \list
117
118 \li Provide the FWHM value itself.
119 \li Provide the resolving power of the instrument that the peak simulation
120 should emulate.
121
122 \endlist
123
124 \enddetails
125 */
126
127 /*!
128 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_resolution
129
130 \brief Resolving power of the instrument.
131 */
132
133 /*!
134 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_fwhm
135
136 \brief Full width at half maximum of the shaped peak.
137 */
138
139 /*!
140 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_massPeakWidthLogic
141
142 \brief Describes the logic used to compute the peak shape width.
143 */
144
145 /*!
146 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_referencePeakMz
147
148 \brief The m/z value to be used when computing the FWHM value starting from a
149 mass spectrometer resolving power.
150 */
151
152 /*!
153 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_pointCount
154
155 \brief The count of points used to shape the peak. Typically between 150 and
156 300.
157 */
158
159 /*!
160 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_withBins
161
162 \brief Tells if bins are requested for the computation.
163
164 There is no need in the context of the calculations performed by the
165 MassPeakShaperConfig class to know if bins are required or not. This variable
166 is useful when multiple peak shapes are combined into a more complex trace or
167 mass spectrum, typically when simulating an isotopic cluster. In this case,
168 each cluster peak centroid is shaped in sequence and then they are all merged
169 into a single trace (no bins) or mass spectrum (binning). The width of the bins
170 is defined using this m_withBins variable.
171 */
172
173 /*!
174 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_binSizeDivisor
175
176 \brief Empirical division factor to apply to \l m_binSize to reduce the size of
177 the bins after the bin size calculation.
178
179 Empirically, a good value is \c 6.
180 */
181
182 /*!
183 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_binSize
184
185 \brief The size of the m/z bins.
186 */
187
188 /*!
189 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_isBinSizeFixed
190
191 \brief Tells if the size of the m/z bins is fixed.
192 */
193
194 /*!
195 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_mzStep
196
197 \brief The m/z distance (a Delta) between to consecutive data points in the
198 shaped mass peak.
199 */
200
201 /*!
202 \variable MsXpS::libXpertMassCore::MassPeakShaperConfig::m_massPeakShapeType
203
204 \brief The requested shape of the mass peak.
205 */
206
207
208 /*!
209 \brief Constructs a MassPeakShaperConfig instance.
210 */
211 ✗ MassPeakShaperConfig::MassPeakShaperConfig(QObject *parent): QObject(parent)
212 {
213 ✗ reset();
214 ✗ }
215
216 /*!
217 \brief Constructs a MassPeakShaperConfig instance as a copy of \a other.
218 */
219 ✗ MassPeakShaperConfig::MassPeakShaperConfig(const MassPeakShaperConfig &other,
220 ✗ QObject *parent)
221 : QObject(parent),
222 ✗ m_resolution(other.m_resolution),
223 ✗ m_fwhm(other.m_fwhm),
224 ✗ m_massPeakWidthLogic(other.m_massPeakWidthLogic),
225 ✗ m_referencePeakMz(other.m_referencePeakMz),
226 ✗ m_pointCount(other.m_pointCount),
227 ✗ m_withBins(other.m_withBins),
228 ✗ m_binSizeDivisor(other.m_binSizeDivisor),
229 ✗ m_binSize(other.m_binSize),
230 ✗ m_isBinSizeFixed(other.m_isBinSizeFixed),
231 ✗ m_mzStep(other.m_mzStep),
232 ✗ m_massPeakShapeType(other.m_massPeakShapeType)
233 {
234 ✗ }
235
236 /*!
237 \brief Destructs this MassPeakShaperConfig instance.
238 */
239 ✗ MassPeakShaperConfig::~MassPeakShaperConfig()
240 {
241 ✗ }
242
243 /*!
244 \brief Assigns \a other to this MassPeakShaperConfig instance.
245 */
246 MassPeakShaperConfig &
247 ✗ MassPeakShaperConfig::initialize(const MassPeakShaperConfig &other)
248 {
249 ✗ if(this == &other)
250 return *this;
251
252 ✗ m_resolution = other.m_resolution;
253 ✗ m_fwhm = other.m_fwhm;
254 ✗ m_massPeakWidthLogic = other.m_massPeakWidthLogic;
255 ✗ m_referencePeakMz = other.m_referencePeakMz;
256 ✗ m_pointCount = other.m_pointCount;
257 ✗ m_withBins = other.m_withBins;
258 ✗ m_binSizeDivisor = other.m_binSizeDivisor;
259 ✗ m_binSize = other.m_binSize;
260 ✗ m_isBinSizeFixed = other.m_isBinSizeFixed;
261 ✗ m_mzStep = other.m_mzStep;
262 ✗ m_massPeakShapeType = other.m_massPeakShapeType;
263
264 ✗ return *this;
265 }
266
267 /*!
268 \brief Returns a newly allocated MassPeakShaperConfig instance initialized using
269 \a other and with parent set to \a parent.
270 */
271 MassPeakShaperConfig *
272 ✗ MassPeakShaperConfig::clone(const MassPeakShaperConfig &other,
273 QObject *parent) const
274 {
275 ✗ MassPeakShaperConfig *copy_p = new MassPeakShaperConfig(parent);
276 ✗ copy_p->initialize(other);
277
278 ✗ return copy_p;
279 }
280
281 /*!
282 \brief Sets the \a resolution (the resolving power of the instrument).
283 */
284 void
285 ✗ MassPeakShaperConfig::setResolution(int resolution)
286 {
287 ✗ m_resolution = resolution;
288 ✗ }
289
290 /*!
291 \brief Returns the resolution (the resolving power of the instrument).
292 */
293 double
294 ✗ MassPeakShaperConfig::getResolution() const
295 {
296 ✗ return m_resolution;
297 }
298
299 /*!
300 \brief Calculates the resolution (resolving power of the instrument).
301
302 The calculation involves using the FWHM (m_fwhm) member datum and the m/z value
303 that is considered to be the reference for the calculation (m_referencePeakMz).
304
305 If any of these two values is not set, then this function returns 0 and sets \a
306 ok to false.
307
308 The calculation is that simple:
309
310 \code
311 m_resolution = m_referencePeakMz / m_fwhm;
312 \endcode
313
314 Because we used the FWHM to compute the resolution and set the calculated value
315 to the \l m_resolution member datum, we keep a record of this by:
316
317 \code
318 m_massPeakWidthLogic = Enums::MassPeakWidthLogic::FWHM;
319 \endcode
320
321 Returns the resolving power as set in \l m_resolution and sets \a ok to true.
322 */
323 int
324 ✗ MassPeakShaperConfig::resolution(bool *ok)
325 {
326 ✗ if(ok == nullptr)
327 ✗ qFatal("The pointer cannot be nullptr.");
328
329 // If we want to compute the resolution that means that we have to have
330 // m_fwhm.
331 ✗ if(!m_fwhm)
332 {
333 ✗ *ok = false;
334 ✗ return 0;
335 }
336
337 ✗ if(!m_referencePeakMz)
338 {
339 ✗ *ok = false;
340 ✗ return 0;
341 }
342
343 ✗ m_resolution = m_referencePeakMz / m_fwhm;
344
345 ✗ *ok = true;
346
347 // We used the FWHM to compute the resolving power.
348 ✗ m_massPeakWidthLogic = Enums::MassPeakWidthLogic::FWHM;
349
350 ✗ return m_resolution;
351 }
352
353 /*!
354 \brief Sets the \a fwhm (full width at half maximum).
355 */
356 void
357 ✗ MassPeakShaperConfig::setFwhm(double fwhm)
358 {
359 ✗ m_fwhm = fwhm;
360 ✗ }
361
362 /*!
363 \brief Gets the fwhm (full width at half maximum).
364 */
365 double
366 ✗ MassPeakShaperConfig::getFwhm() const
367 {
368 ✗ return m_fwhm;
369 }
370
371 /*!
372 \brief Calculates the fwhm (full width at half maximum).
373
374 The calculation involves using the instrument's resolving power (m_resolution)
375 member datum and the m/z value that is considered to be the reference for the
376 calculation (m_referencePeakMz).
377
378 If any of these two values is not set, then this function returns 0 and sets \a
379 ok to false.
380
381 The calculation is that simple:
382
383 \code
384 m_fwhm = m_referencePeakMz / m_resolution;
385 \endcode
386
387 Because we used the resolution to compute the FWHM and set the calculated
388 value
389 to the \l m_fwhm member datum, we keep a record of this by:
390
391 \code
392 m_massPeakWidthLogic = Enums::MassPeakWidthLogic::RESOLUTION;
393 \endcode
394
395 Returns the FWHM value as set in \l m_fwhm and sets \a ok to true.
396 */
397 double
398 ✗ MassPeakShaperConfig::fwhm(bool *ok)
399 {
400 ✗ if(ok == nullptr)
401 ✗ qFatal("The pointer cannot be nullptr.");
402
403 // Or we need to compute it using the mz passed as parameter and the
404 // resolution.
405 ✗ if(!m_resolution)
406 {
407 ✗ *ok = false;
408 ✗ return 0;
409 }
410
411 ✗ if(!m_referencePeakMz)
412 {
413 // qDebug() << "There is no reference peak centroid!";
414
415 ✗ *ok = false;
416 ✗ return 0;
417 }
418
419 ✗ m_fwhm = m_referencePeakMz / m_resolution;
420 ✗ *ok = true;
421
422 // We used the resolving power to compute the FWHM.
423 ✗ m_massPeakWidthLogic = Enums::MassPeakWidthLogic::RESOLUTION;
424
425 ✗ return m_fwhm;
426 }
427
428 /*!
429 \brief Returns the half of the FWMH (m_fwhm) for use in the Lorentzian shape
430 calculation.
431
432 Uses the \l fwhm() function to compute the FWHM value. If the
433 FWHM calculation fails, returns 0 and \a ok is set to false, otherwise returns
434 half of FWHM and \a ok is set to true.
435
436 \sa fwhm()
437 */
438 double
439 ✗ MassPeakShaperConfig::halfFwhm(bool *ok)
440 {
441 ✗ double fwhm_value = fwhm(ok);
442
443 ✗ if(!*ok)
444 return 0;
445
446 ✗ return (fwhm_value / 2);
447 }
448
449 /*!
450 \brief Sets the reference m/z value required for calculations to \a mz.
451 */
452 void
453 ✗ MassPeakShaperConfig::setReferencePeakMz(double mz)
454 {
455 ✗ m_referencePeakMz = mz;
456 ✗ }
457
458 /*!
459 \brief Gets the reference m/z value required for calculations.
460 */
461 double
462 ✗ MassPeakShaperConfig::getReferencePeakMz() const
463 {
464 ✗ return m_referencePeakMz;
465 }
466
467 /*!
468 \brief Sets the requirement to prepare m/z bins at a later computing stage to
469 \a with_bins.
470
471 \sa IsotopicClusterShaper::run(), isWithBins()
472 */
473 void
474 ✗ MassPeakShaperConfig::setWithBins(bool with_bins)
475 {
476 ✗ m_withBins = with_bins;
477 ✗ }
478
479 /*!
480 \brief Returns the requirement to prepare m/z bins at a later computing stage.
481
482 \sa IsotopicClusterShaper::run(), setWithBins()
483 */
484 bool
485 ✗ MassPeakShaperConfig::isWithBins() const
486 {
487 ✗ return m_withBins;
488 }
489
490 /*!
491 \brief Sets the \a bin_size.
492 */
493 void
494 ✗ MassPeakShaperConfig::setBinSize(double bin_size)
495 {
496 ✗ m_binSize = bin_size;
497 ✗ }
498
499 /*!
500 \brief Computes the bin size.
501
502 If there is no requirement for bins (m_withBins is false), returns 0 and set \a
503 ok to true.
504
505 In order to compute the bin size we need that at least the FWHM (m_fwhm) or the
506 resolving power (m_resolution) be set. If none of these values are set, this
507 function returns 0 and sets \a ok to false.
508
509 If the bin size was fixed (m_isBinSizeFixed is true), then the bin size
510 (m_binSize) must be set. If that is not the case, the function returns 0 and
511 sets \a ok to false.
512
513 If the FWHM value (m_fwhm) is set, then it is used right away. Otherwise, the
514 FWHM is computed starting from the resolving power (m_resolution). If that
515 computation fails, the function returns 0 and sets \a ok to false.
516
517 Starting from the FWHM value (m_fwhm), the bin size calculation requires that
518 the m_binSizeDivisor be > 1. The bin size is thus computed as the ratio FWHM /
519 m_binSizeDivisor, and the obtained value is set to m_binSize.
520
521 Empirically, a value of 6 for m_binSizeDivisor, yields bin sizes that allow
522 combining correctly multiple peak shapes into a mass spectrum. Essentially,
523 that means that 6 individual m/z bins are required to combine nicely all the
524 peaks shapes obtained for all the peak centroids in a given isotopic cluster,
525 for example.
526
527 At this point, the function returns the bin size and sets \a ok to true.
528
529 \sa setBinSizeDivisor()
530 */
531 double
532 ✗ MassPeakShaperConfig::binSize(bool *ok)
533 {
534 ✗ if(ok == nullptr)
535 ✗ qFatal("The pointer cannot be nullptr.");
536
537 // If the bin size was set before, then, just return it.
538 // if(m_binSize)
539 //{
540 //*ok = true;
541 // return m_binSize;
542 //}
543
544 ✗ if(!m_withBins)
545 {
546 // qDebug() << "Bins are not requested, just return 0 and set true.";
547 ✗ *ok = true;
548 ✗ return 0;
549 }
550
551 // In order to compute the bin Size, we need the FWHM and the number of
552 // points.
553
554 ✗ if(!m_resolution && !m_fwhm)
555 {
556 // qDebug() << "That's an error when neither resolution nor FWHM is set.";
557 ✗ *ok = false;
558 ✗ return 0;
559 }
560
561 ✗ if(m_fwhm)
562 {
563 // FWHM is fine, we can use that immediately.
564
565 // qDebug() << "FWHM:" << m_fwhm;
566
567 ✗ if(!m_pointCount)
568 {
569 // qDebug() << "That's an error that the point count is 0.";
570 ✗ *ok = false;
571 ✗ return 0;
572 }
573 }
574 else
575 {
576 // We have to work with the resolution.
577
578 // qDebug() << "Resolution:" << m_resolution;
579
580 ✗ fwhm(ok);
581
582 ✗ if(!*ok)
583 {
584 // qDebug()
585 //<< "Could not compute FWHM on the basis of the resolution.";
586
587 ✗ if(!m_pointCount)
588 {
589 // qDebug() << "That's an error that the point count is 0.";
590 ✗ *ok = false;
591 ✗ return 0;
592 }
593 }
594 }
595
596 ✗ if(m_isBinSizeFixed)
597 {
598 // The bin size has to be set and must not be changed, as the user has
599 // set it manually.
600
601 ✗ if(!m_binSize)
602 {
603 // qDebug() << "The bin size should be set manually but is not set.";
604 ✗ *ok = false;
605 ✗ return 0;
606 }
607 }
608 else
609 {
610 ✗ m_binSize = m_fwhm / m_binSizeDivisor;
611
612 // qDebug() << "The bin size was computed:" << m_binSize;
613 }
614
615 ✗ *ok = true;
616 ✗ return m_binSize;
617 }
618
619 /*!
620 \brief Returns (no computation) the bin size.
621 */
622 double
623 ✗ MassPeakShaperConfig::getBinSize() const
624 {
625 ✗ return m_binSize;
626 }
627
628 /*!
629 \brief Sets the requirement that the bin size be set and fixed (not modifiable
630 by computations) to \a is_fixed.
631
632 When \a is_fixed is true, the \l binSize() function returns the bin size
633 without trying to compute it.
634
635 \sa binSize()
636 */
637 void
638 ✗ MassPeakShaperConfig::setBinSizeFixed(bool is_fixed)
639 {
640 ✗ m_isBinSizeFixed = is_fixed;
641 ✗ }
642
643 /*
644 \brief Gets the requirement that the bin size be set and fixed (not modifiable
645 by computations).
646 */
647 bool
648 ✗ MassPeakShaperConfig::getBinSizeFixed()
649 {
650 ✗ return m_isBinSizeFixed;
651 }
652
653 /*!
654 \brief Sets the bin size computation dividing \a factor.
655
656 When the bin size is computed (m_isBinSizeFixed is false), that value is
657 determined by dividing the FWHM value by this \a factor (m_binSizeDivisor).
658
659 Empirically, a value of 6 for m_binSizeDivisor, yields bin sizes that allow
660 combining correctly multiple peak shapes into a mass spectrum. Essentially,
661 that means that 6 individual m/z bins are required to combine nicely all the
662 peaks shapes obtained for all the peak centroids in a given isotopic cluster,
663 for example.
664 */
665 void
666 ✗ MassPeakShaperConfig::setBinSizeDivisor(int factor)
667 {
668 ✗ if(std::abs(factor) < 1)
669 ✗ qFatal("Programming error.");
670
671 ✗ m_binSizeDivisor = std::abs(factor);
672 ✗ }
673
674 /*!
675 \brief Returns the bin size computation dividing factor.
676
677 \sa setBinSizeDivisor()
678 */
679 int
680 ✗ MassPeakShaperConfig::getBinSizeDivisor() const
681 {
682 ✗ return m_binSizeDivisor;
683 }
684
685 /*!
686 \brief Sets the \a point_count to be used to shape the mass peak
687 around the m/z centroid value.
688
689 Typically, a value between 150 and 200 points is fine to nicely shape a m/z
690 peak centroid.
691 */
692 void
693 ✗ MassPeakShaperConfig::setPointCount(int point_count)
694 {
695 ✗ m_pointCount = point_count;
696 ✗ }
697
698 /*!
699 \brief Gets the count of points to be used to shape the mass peak around the
700 m/z centroid value.
701 */
702 int
703 ✗ MassPeakShaperConfig::getPointCount() const
704 {
705 ✗ return m_pointCount;
706 }
707
708 /*!
709 \brief Sets the type of mass peak shape to \a mass_peak_shape_type.
710
711 \sa MsXpS::libXpertMassCore::Enums::MassPeakShapeType
712 */
713 void
714 ✗ MassPeakShaperConfig::setMassPeakShapeType(
715 Enums::MassPeakShapeType mass_peak_shape_type)
716 {
717 ✗ m_massPeakShapeType = mass_peak_shape_type;
718 ✗ }
719
720 /*!
721 \brief Gets the type of mass peak shape.
722
723 \sa MsXpS::libXpertMassCore::Enums::MassPeakShapeType
724 */
725 Enums::MassPeakShapeType
726 ✗ MassPeakShaperConfig::getMassPeakShapeType() const
727 {
728 ✗ return m_massPeakShapeType;
729 }
730
731 /*!
732 \brief Sets the mass peak width calculation \a logic.
733
734 The full mass peak width at half peak maximum (FWHM) can either be set manually
735 or be computed from a reference m/z value and the instrument's resolving power.
736
737 \sa MsXpS::libXpertMassCore::Enums::MassPeakWidthLogic
738 */
739 void
740 ✗ MassPeakShaperConfig::setMassPeakWidthLogic(Enums::MassPeakWidthLogic logic)
741 {
742 ✗ m_massPeakWidthLogic = logic;
743 ✗ }
744
745 /*!
746 \brief Gets the mass peak width calculation logic.
747
748 \sa MsXpS::libXpertMassCore::Enums::MassPeakWidthLogic
749 */
750 Enums::MassPeakWidthLogic
751 ✗ MassPeakShaperConfig::getMassPeakWidthLogic() const
752 {
753 ✗ return m_massPeakWidthLogic;
754 }
755
756 double
757 ✗ MassPeakShaperConfig::c(bool *ok)
758 {
759 // c in the Gaussian curve is related to the fwhm value:
760
761 ✗ fwhm(ok);
762
763 ✗ if(!*ok)
764 {
765 return 0;
766 }
767
768 ✗ double c = m_fwhm / (2 * sqrt(2 * log(2)));
769
770 // qDebug() << "c:" << c;
771
772 ✗ *ok = true;
773
774 ✗ return c;
775 }
776
777 double
778 ✗ MassPeakShaperConfig::a(bool *ok)
779 {
780 // double pi = 3.1415926535897932384626433832795029;
781
782 ✗ double c_value = c(ok);
783
784 ✗ if(!*ok)
785 {
786 return 0;
787 }
788
789 ✗ double a = (1 / (c_value * sqrt(2 * M_PI)));
790
791 // qDebug() << "a:" << a;
792
793 ✗ *ok = true;
794
795 ✗ return a;
796 }
797
798 double
799 ✗ MassPeakShaperConfig::gamma(bool *ok)
800 {
801 ✗ fwhm(ok);
802
803 ✗ if(!*ok)
804 {
805 return 0;
806 }
807
808 ✗ double gamma = m_fwhm / 2;
809
810 // qDebug() << "gamma:" << gamma;
811
812 ✗ *ok = true;
813
814 ✗ return gamma;
815 }
816
817 /*!
818 \brief Sets the \a mz_step.
819
820 The m/z step value is the distance between two consecutive points in the peak
821 shape.
822
823 \sa getMzStep()
824 */
825 void
826 ✗ MassPeakShaperConfig::setMzStep(double mz_step)
827 {
828 ✗ m_mzStep = mz_step;
829 ✗ }
830
831 /*!
832 \brief Gets the m/z step.
833
834 The m/z step value is the distance between two consecutive points in the peak
835 shape.
836
837 \sa setMzStep()
838 */
839 double
840 ✗ MassPeakShaperConfig::getMzStep() const
841 {
842 ✗ return m_mzStep;
843 }
844
845 /*!
846 \brief Calculates the m/z step.
847
848
849 The m/z step value is the distance between two consecutive points in the peak
850 shape. To compute that value, the full m/z width of the calculated shape (not
851 only the width at half maximum, FWHM) is divided by the total number of data
852 points that make the final shape of the m/z peak.
853
854 The first variable is FWHM_PEAK_SPAN_FACTOR * m_fwhm, and the second
855 variable is m_pointCount. The calculation is thus:
856
857 \code
858 m_mzStep = (FWHM_PEAK_SPAN_FACTOR * m_fwhm) / m_pointCount;
859 \endcode
860
861 The first step is to compute the FWHM and then to check the value of
862 m_pointCount (that cannot be 0). If any of these fails, the function returns 0
863 and set \a ok to false, otherwise the computed value is set to m_mzStep and
864 returned, while \a ok is set to true.
865
866 \sa FWHM_PEAK_SPAN_FACTOR
867 */
868 double
869 ✗ MassPeakShaperConfig::mzStep(bool *ok)
870 {
871 // But what is the mz step ?
872 //
873 // We want the shape to be able to go down to baseline. Thus we want that
874 // the shape to have a "basis" (or, better, a "ground") corresponding to
875 // twice the FWHM on the left of the centroid and to twice the FWHM on the
876 // right (that makes in total FWHM_PEAK_SPAN_FACTOR * FWHM, that is,
877 // FWHM_PEAK_SPAN_FACTOR = 4).
878
879 ✗ fwhm(ok);
880
881 ✗ if(!*ok)
882 {
883 return 0;
884 }
885
886 ✗ if(!m_pointCount)
887 {
888 ✗ *ok = false;
889 ✗ return 0;
890 }
891
892 ✗ m_mzStep = (FWHM_PEAK_SPAN_FACTOR * m_fwhm) / m_pointCount;
893
894 ✗ return m_mzStep;
895 }
896
897 /*!
898 \brief Resets this MassPeakShaperConfig instance to default values like at
899 construction time.
900 */
901 void
902 ✗ MassPeakShaperConfig::reset()
903 {
904 // Values to start over.
905
906 ✗ m_resolution = 0;
907 ✗ m_fwhm = 0;
908 ✗ m_referencePeakMz = 0;
909 ✗ m_pointCount = 0;
910 ✗ m_withBins = false;
911 ✗ m_binSizeDivisor = 6;
912 ✗ m_binSize = 0;
913 ✗ m_isBinSizeFixed = false;
914 ✗ m_mzStep = 0;
915 ✗ m_massPeakShapeType = Enums::MassPeakShapeType::NOT_SET;
916 ✗ }
917
918 /*!
919 \brief Calculates the various parameters of the peak shape using member data.
920
921 This function first checks that all the required data are set. Then this
922 functions computes the FWHM value required to shape the peak centroid. Once the
923 basic data have been computed or set, the parameters of the shape are computed:
924 c, a, gamma.
925
926 Returns true if the computation was successful, false otherwise.
927 */
928 bool
929 ✗ MassPeakShaperConfig::resolve(libXpertMassCore::ErrorList &error_list)
930 {
931 // We need to try to set all the relevant parameters by calculation.
932
933 ✗ bool ok = false;
934
935 // These are the essential parameters:
936
937 ✗ if(!m_referencePeakMz)
938 {
939 ✗ error_list.append("Missing reference peak m/z value");
940 ✗ return false;
941 }
942
943 ✗ if(!m_fwhm && !m_resolution)
944 {
945 ✗ error_list.append("Both FWHM and resolution are naught");
946 ✗ return false;
947 }
948
949 ✗ if(!m_pointCount)
950 {
951 ✗ error_list.append("The count of points to shape the peak is naught");
952 ✗ return false;
953 }
954
955 // At this point we should be able to compute the relevant data.
956
957 // The FWHM is the *leading* value for the determination of the peak shape's
958 // width at half maximum. If that FWHM value is 0, then we resort to the
959 // resolution. Both R and FWHM cannot be 0!
960 ✗ if(m_fwhm)
961 {
962 // If we have FWHM, immediately try to compute the resolution as we'll
963 // need it later. FWHM takes precedence over resolution!
964 ✗ resolution(&ok);
965
966 ✗ if(!ok)
967 {
968 ✗ error_list.append("Failed to compute resolution value");
969 ✗ return false;
970 }
971 }
972 else
973 {
974 // We should be able to compute FWHM by resorting to the resolution.
975
976 ✗ fwhm(&ok);
977
978 ✗ if(!ok)
979 {
980 ✗ error_list.append("Failed to compute FWHM value");
981 ✗ return false;
982 }
983 }
984
985 // Now check if we have and can compute the bins.
986 // But we do this only if the user has not stated that the bin size has to
987 // be set manually.
988
989 // qDebug() << "In the resolve, check the bin size";
990
991 ✗ binSize(&ok);
992
993 ✗ if(!ok)
994 {
995 ✗ error_list.append("Failed to compute the bin size");
996 ✗ return false;
997 }
998
999 ✗ mzStep(&ok);
1000
1001 ✗ if(!ok)
1002 {
1003 ✗ error_list.append("Failed to compute the m/z step");
1004 ✗ return false;
1005 }
1006 // Now the other parameters for the shape.
1007
1008 ✗ c(&ok);
1009
1010 ✗ if(!ok)
1011 {
1012 ✗ error_list.append("Failed to compute the c parameter");
1013 ✗ return false;
1014 }
1015
1016 ✗ a(&ok);
1017
1018 ✗ if(!ok)
1019 {
1020 ✗ error_list.append("Failed to compute the a parameter");
1021 ✗ return false;
1022 }
1023
1024 ✗ gamma(&ok);
1025
1026 ✗ if(!ok)
1027 {
1028 ✗ error_list.append("Failed to compute the gamma parameter");
1029 ✗ return false;
1030 }
1031
1032 return true;
1033 }
1034
1035 /*!
1036 \brief Returns a string representing this MassPeakShaperConfig instance.
1037
1038 The configuration of the MassPeakShaper is first resolved. If that step fails,
1039 an empty string is returned, otherwise the configuration is returned as a
1040 string.
1041 */
1042 QString
1043 ✗ MassPeakShaperConfig::toString()
1044 {
1045 ✗ QString string;
1046
1047 ✗ libXpertMassCore::ErrorList error_list;
1048 ✗ bool ok = resolve(error_list);
1049
1050 ✗ if(!ok)
1051 ✗ return QString();
1052
1053 ✗ QString peak_shape_text;
1054 ✗ if(m_massPeakShapeType == Enums::MassPeakShapeType::GAUSSIAN)
1055 ✗ peak_shape_text = "Gaussian";
1056 ✗ if(m_massPeakShapeType == Enums::MassPeakShapeType::LORENTZIAN)
1057 ✗ peak_shape_text = "Lorentzian";
1058
1059 ✗ QString with_bins_text;
1060 ✗ if(m_withBins)
1061 ✗ with_bins_text +=
1062 ✗ QString("With bins of size: %1 m/z.\n").arg(m_binSize, 0, 'f', 10);
1063 else
1064 ✗ with_bins_text = "Without bins.\n";
1065
1066 ✗ string = QString(
1067 "%1 peak shaping:\n"
1068 "Configuration for reference m/z value: %2\n"
1069 "Resolution: %3\n"
1070 "FWHM: %4\n"
1071 "%5\n"
1072 "Number of points to shape the peak: %6\n"
1073 "c: %7\n"
1074 "c^2: %8\n"
1075 ✗ "mz step: %9\n\n")
1076 ✗ .arg(peak_shape_text)
1077 ✗ .arg(m_referencePeakMz, 0, 'f', 5)
1078 ✗ .arg(m_resolution)
1079 ✗ .arg(m_fwhm, 0, 'f', 5)
1080 ✗ .arg(with_bins_text)
1081 ✗ .arg(m_pointCount)
1082 ✗ .arg(c(&ok), 0, 'f', 5)
1083 ✗ .arg(c(&ok) * c(&ok), 0, 'f', 5)
1084 ✗ .arg(m_mzStep, 0, 'f', 5);
1085
1086 ✗ return string;
1087 ✗ }
1088
1089 void
1090 ✗ MassPeakShaperConfig::registerJsConstructor(QJSEngine *engine)
1091
1092 {
1093 ✗ if(!engine)
1094 {
1095 ✗ qWarning()
1096 ✗ << "Cannot register MassPeakShaperConfig class: engine is null";
1097 ✗ return;
1098 }
1099
1100 // Register the meta object as a constructor
1101
1102 ✗ QJSValue jsMetaObject =
1103 ✗ engine->newQMetaObject(&MassPeakShaperConfig::staticMetaObject);
1104 ✗ engine->globalObject().setProperty("MassPeakShaperConfig", jsMetaObject);
1105 ✗ }
1106
1107
1108 } // namespace libXpertMassCore
1109
1110 } // namespace MsXpS
1111