libpappsomspp
Library for mass spectrometry
precision.cpp
Go to the documentation of this file.
1 /**
2  * \file pappsomspp/mass_range.cpp
3  * \date 4/3/2015
4  * \author Olivier Langella
5  * \brief object to handle a mass range (an mz value + or - some delta)
6  */
7 
8 /*******************************************************************************
9  * Copyright (c) 2015 Olivier Langella <Olivier.Langella@moulon.inra.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  * Contributors:
27  * Olivier Langella <Olivier.Langella@moulon.inra.fr> - initial API and
28  *implementation
29  ******************************************************************************/
30 
31 #include "precision.h"
32 #include "mzrange.h"
34 #include <QStringList>
35 #include <cmath>
36 #include <QDebug>
37 
38 namespace pappso
39 {
40 
41 
43  MapDaltonPrecision ret;
44 
45  return ret;
46 }();
47 
48 
50  MapPpmPrecision ret;
51 
52  return ret;
53 }();
54 
55 
57  MapResPrecision ret;
58 
59  return ret;
60 }();
61 
62 
65 {
66  return m_nominal;
67 }
68 
69 
71 PrecisionFactory::fromString(const QString &str)
72 {
73 
74  // The format of the string is <number><space *><string> with string either
75  // "ppm" or "dalton" or "res".
76  //
77  // If there only once component, that is, <string> is omitted and charge is
78  // not provided, then "dalton" is considered.
79 
80  QStringList list = str.split(QRegExp("\\s+"), QString::SkipEmptyParts);
81 
82  if(list.size() > 0)
83  {
84  bool ok;
85  pappso_double value = list[0].toDouble(&ok);
86  if(!ok)
87  {
89  QObject::tr("ERROR getting precision from string :\nunable to "
90  "convert %1 to number in %2")
91  .arg(value)
92  .arg(str));
93  }
94  if(list.size() == 1)
95  {
97  }
98  else if(list.size() == 2)
99  {
100  if(list[1].toLower() == "dalton")
101  {
103  }
104 
105  if(list[1].toLower() == "ppm")
106  {
107  return PrecisionFactory::getPpmInstance(value);
108  }
109 
110  if(list[1].toLower() == "res")
111  {
112  return PrecisionFactory::getResInstance(value);
113  }
114 
115  throw ExceptionNotPossible(
116  QObject::tr("ERROR getting precision from string :\nprecision "
117  "unit %1 to not known in %2")
118  .arg(list[1])
119  .arg(str));
120  }
121  }
122 
123  throw ExceptionNotPossible(QObject::tr("ERROR getting precision from string "
124  ":\nunable to convert %1 to precision")
125  .arg(str));
126 }
127 
130 {
131  MapDaltonPrecision::iterator it = m_mapDalton.find(value);
132  if(it == m_mapDalton.end())
133  {
134  // not found
135  std::pair<MapDaltonPrecision::iterator, bool> insert_res =
136  m_mapDalton.insert(std::pair<pappso_double, DaltonPrecision *>(
137  value, new DaltonPrecision(value)));
138  it = insert_res.first;
139  }
140  else
141  {
142  // found
143  }
144  return it->second;
145 }
146 
147 
150 {
151  if(!value)
152  throw ExceptionNotPossible(
153  QObject::tr("Fatal error at precision.cpp "
154  "-- ERROR trying to set a Resolution precision value of 0. "
155  "Program aborted."));
156 
157  MapPpmPrecision::iterator it = m_mapPpm.find(value);
158 
159  if(it == m_mapPpm.end())
160  {
161  // Not found.
162  std::pair<MapPpmPrecision::iterator, bool> insert_res =
163  m_mapPpm.insert(std::pair<pappso_double, PpmPrecision *>(
164  value, new PpmPrecision(value)));
165  it = insert_res.first;
166  }
167  else
168  {
169  // found
170  }
171  return it->second;
172 }
173 
174 
177 {
178  if(!value)
179  throw ExceptionNotPossible(
180  QObject::tr("Fatal error at precision.cpp "
181  "-- ERROR trying to set a Resolution precision value of 0. "
182  "Program aborted."));
183 
184  MapResPrecision::iterator it = m_mapRes.find(value);
185 
186  if(it == m_mapRes.end())
187  {
188  // not found
189  std::pair<MapResPrecision::iterator, bool> insert_res =
190  m_mapRes.insert(std::pair<pappso_double, ResPrecision *>(
191  value, new ResPrecision(value)));
192  it = insert_res.first;
193  }
194  else
195  {
196  // found
197  }
198  return it->second;
199 }
200 
201 
203 {
204 }
205 
207 {
208 }
209 
211 DaltonPrecision::unit() const
212 {
213  return PrecisionUnit::dalton;
214 }
215 
217 DaltonPrecision::delta([[maybe_unused]] pappso_double value) const
218 {
219  return m_nominal;
220 }
221 
222 QString
224 {
225  return (QString("%1 dalton").arg(m_nominal));
226 }
227 
228 
230 {
231 }
232 
233 
235 {
236 }
237 
239 PpmPrecision::unit() const
240 {
241  return PrecisionUnit::ppm;
242 }
243 
244 
247 {
248  return ((value / ONEMILLION) * m_nominal);
249 }
250 
251 
252 QString
254 {
255  return (QString("%1 ppm").arg(m_nominal));
256 }
257 
258 
260 {
261 }
262 
263 
265 {
266 }
267 
269 ResPrecision::unit() const
270 {
271  return PrecisionUnit::res;
272 }
273 
274 
277 {
278  return (value / m_nominal);
279 }
280 
281 
282 QString
284 {
285  return (QString("%1 res").arg(m_nominal));
286 }
287 
288 } // namespace pappso
pappso::pappso_double
double pappso_double
A type definition for doubles.
Definition: types.h:69
pappso::ResPrecision::ResPrecision
ResPrecision(pappso_double x)
Definition: precision.cpp:280
pappso::PrecisionFactory::m_mapRes
static MapResPrecision m_mapRes
Definition: precision.h:156
pappso::PpmPrecision::delta
virtual pappso_double delta(pappso_double value) const override
Definition: precision.cpp:267
pappso::PrecisionFactory::getPpmInstance
static PrecisionPtr getPpmInstance(pappso_double value)
Definition: precision.cpp:170
pappso::PrecisionFactory::MapDaltonPrecision
std::map< pappso_double, DaltonPrecision * > MapDaltonPrecision
Definition: precision.h:149
pappso::DaltonPrecision::~DaltonPrecision
virtual ~DaltonPrecision()
Definition: precision.cpp:227
pappso::PrecisionUnit::dalton
@ dalton
pappso
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition: aa.cpp:39
pappso::ONEMILLION
const pappso_double ONEMILLION(1000000)
pappso::ResPrecision::unit
virtual PrecisionUnit unit() const override
Definition: precision.cpp:290
pappso::ResPrecision::toString
virtual QString toString() const override
Definition: precision.cpp:304
pappso::PpmPrecision::toString
virtual QString toString() const override
Definition: precision.cpp:274
pappso::ExceptionNotPossible
Definition: exceptionnotpossible.h:53
pappso::ResPrecision::~ResPrecision
virtual ~ResPrecision()
Definition: precision.cpp:285
pappso::DaltonPrecision::delta
virtual pappso_double delta(pappso_double value) const override
Definition: massspectrumcombinerfactory.cpp:305
pappso::PeptideIonCter::x
@ x
pappso::ResPrecision::delta
virtual pappso_double delta(pappso_double value) const override
Definition: precision.cpp:297
pappso::PrecisionUnit::res
@ res
pappso::PrecisionFactory::MapPpmPrecision
std::map< pappso_double, PpmPrecision * > MapPpmPrecision
Definition: precision.h:150
pappso::PrecisionFactory::getDaltonInstance
static PrecisionPtr getDaltonInstance(pappso_double value)
Definition: precision.cpp:150
pappso::PrecisionUnit::ppm
@ ppm
pappso::DaltonPrecision::unit
virtual PrecisionUnit unit() const override
Definition: precision.cpp:232
pappso::PrecisionBase::getNominal
virtual pappso_double getNominal() const final
Definition: precision.cpp:85
pappso::PpmPrecision::~PpmPrecision
virtual ~PpmPrecision()
Definition: precision.cpp:255
pappso::PrecisionPtr
const PrecisionBase * PrecisionPtr
Definition: precision.h:143
pappso::DaltonPrecision::DaltonPrecision
DaltonPrecision(pappso_double x)
Definition: precision.cpp:223
pappso::PrecisionFactory::m_mapDalton
static MapDaltonPrecision m_mapDalton
Definition: precision.h:154
pappso::PrecisionUnit
PrecisionUnit
Definition: types.h:84
pappso::PrecisionBase
Definition: precision.h:65
pappso::PrecisionFactory::MapResPrecision
std::map< pappso_double, ResPrecision * > MapResPrecision
Definition: precision.h:151
precision.h
pappso::DaltonPrecision::toString
virtual QString toString() const override
Definition: precision.cpp:244
mzrange.h
pappso::PpmPrecision::unit
virtual PrecisionUnit unit() const override
Definition: precision.cpp:260
pappso::PrecisionBase::m_nominal
const pappso_double m_nominal
Definition: precision.h:88
pappso::PpmPrecision
Definition: precision.h:105
pappso::PrecisionFactory::m_mapPpm
static MapPpmPrecision m_mapPpm
Definition: precision.h:155
pappso::PrecisionFactory::getResInstance
static PrecisionPtr getResInstance(pappso_double value)
Definition: precision.cpp:197
pappso::PrecisionFactory::fromString
static PrecisionPtr fromString(const QString &str)
Definition: precision.cpp:92
exceptionnotpossible.h
pappso::PpmPrecision::PpmPrecision
PpmPrecision(pappso_double x)
Definition: precision.cpp:250