libpappsomspp
Library for mass spectrometry
filterchargedeconvolution.cpp
Go to the documentation of this file.
1 /**
2  * \file pappsomspp/processing/filters/filtertdfcorrectpeak.cpp
3  * \date 30/09/2020
4  * \author Thomas Renne
5  * \brief Sum peaks and transform mz to fit charge = 1
6  */
7 
8 /*******************************************************************************
9  * Copyright (c) 2020 Olivier Langella <Olivier.Langella@u-psud.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  ******************************************************************************/
28 #include <QDebug>
29 #include "../../exception/exceptionnotrecognized.h"
30 
31 using namespace pappso;
32 
34  const QString &strBuildParams)
35 {
36  buildFilterFromString(strBuildParams);
37 }
38 
39 
41  : m_precisionPtrZ1(precision_ptr)
42 {
45  m_precisionPtrZ1 = precision_ptr;
47  m_precisionPtrZ1, 0.5);
48 
49  // pappso::PrecisionFactory::getPrecisionDividedBy(m_precisionPtrZ1, 2):
50 
51  qInfo() << m_precisionPtrZ2->getNominal();
52 }
53 
55  const FilterChargeDeconvolution &other)
56  : m_precisionPtrZ1(other.m_precisionPtrZ1),
57  m_precisionPtrZ2(other.m_precisionPtrZ2)
58 {
61 }
62 
64 {
65 }
66 
67 
68 void
70  const QString &strBuildParams)
71 {
72  //"chargeDeconvolution|0.02dalton"
73  qDebug();
74  if(strBuildParams.startsWith("chargeDeconvolution|"))
75  {
76  QStringList params =
77  strBuildParams.split("|").back().split(";", QString::SkipEmptyParts);
78 
79  QString precision = params.at(0);
80  m_precisionPtrZ1 =
81  PrecisionFactory::fromString(precision.replace("dalton", " dalton")
82  .replace("ppm", " ppm")
83  .replace("res", " res"));
84 
85  qDebug();
86  m_precisionPtrZ2 =
88  m_precisionPtrZ1, 0.5);
89 
90 
91  m_diffC12C13_z1 = DIFFC12C13;
92  m_diffC12C13_z2 = DIFFC12C13 / 2;
93  }
94  else
95  {
97  QString("building chargeDeconvolution from string %1 is not possible")
98  .arg(strBuildParams));
99  }
100  qDebug();
101 }
102 
103 
104 QString
106 {
107  QString strCode =
108  QString("chargeDeconvolution|%1").arg(m_precisionPtrZ1->toString());
109  strCode.replace(" ", "");
110 
111  return strCode;
112 }
113 
114 Trace &
116 {
117  qDebug();
118  std::vector<FilterChargeDeconvolution::DataPointInfoSp> data_points_info;
119  data_points.sortY();
120 
121  Trace new_trace;
122 
123  for(auto &data_point : data_points)
124  {
125  addDataPointToList(data_points_info, data_point);
126  }
127  computeBestChargeOfDataPoint(data_points_info);
128 
129  qDebug() << data_points_info.size();
130  computeIsotopeDeconvolution(data_points_info);
131  qDebug() << data_points_info.size();
132  transformToMonoChargedForAllDataPoint(data_points_info);
133  for(DataPointInfoSp &dpi : data_points_info)
134  {
135  qDebug() << dpi->new_mono_charge_data_point.x << dpi->z_charge;
136  new_trace.push_back(dpi->new_mono_charge_data_point);
137  }
138 
139  new_trace.sortX();
140  data_points = std::move(new_trace);
141 
142  qDebug();
143  return data_points;
144 }
145 
146 void
148  std::vector<FilterChargeDeconvolution::DataPointInfoSp> &points,
149  pappso::DataPoint &data_point) const
150 {
151  DataPointInfoSp new_dpi(std::make_shared<DataPointInfo>());
152 
153  new_dpi->data_point = data_point;
154  MzRange range1(data_point.x + m_diffC12C13_z1, m_precisionPtrZ1);
155  new_dpi->z1_range = std::pair<double, double>(range1.lower(), range1.upper());
156  MzRange range2(data_point.x + m_diffC12C13_z2, m_precisionPtrZ2);
157  new_dpi->z2_range = std::pair<double, double>(range2.lower(), range2.upper());
158  addDataPointRefByExclusion(points, new_dpi);
159  points.push_back(new_dpi);
160 }
161 
162 void
164  std::vector<FilterChargeDeconvolution::DataPointInfoSp> &points,
166 {
167  // add datapoint which match the mz_range = 1 to z1_list
168  auto i_z1 = points.begin(), end = points.end();
169  while(i_z1 != end)
170  {
171  // get the datapoint which match the range
172  i_z1 = std::find_if(i_z1, end, [&new_dpi](DataPointInfoSp dpi) {
173  return (new_dpi->data_point.x >= dpi->z1_range.first &&
174  new_dpi->data_point.x <= dpi->z1_range.second);
175  });
176  if(i_z1 != end)
177  {
178  // add the datapoint to the list and add the parent pointer
179  i_z1->get()->z1_vect.push_back(new_dpi);
180  new_dpi->parent = *i_z1;
181  DataPointInfoSp parent_z1 = i_z1->get()->parent;
182  while(parent_z1 != nullptr)
183  {
184  parent_z1.get()->z1_vect.push_back(new_dpi);
185  parent_z1 = parent_z1->parent;
186  }
187  i_z1++;
188  }
189  }
190 
191  // add datapoint which match the mz_range = 2 to z2_list
192  auto i_z2 = points.begin();
193  while(i_z2 != end)
194  {
195  // get the datapoint which match the range
196  i_z2 = std::find_if(i_z2, end, [&new_dpi](DataPointInfoSp dpi) {
197  return (new_dpi->data_point.x >= dpi->z2_range.first &&
198  new_dpi->data_point.x <= dpi->z2_range.second);
199  });
200  if(i_z2 != end)
201  {
202  // add the datapoint to the list and add the parent pointer
203  i_z2->get()->z2_vect.push_back(new_dpi);
204  new_dpi->parent = *i_z2;
205  DataPointInfoSp parent_z2 = i_z2->get()->parent;
206  while(parent_z2 != nullptr)
207  {
208  parent_z2.get()->z2_vect.push_back(new_dpi);
209  parent_z2 = parent_z2->parent;
210  }
211  i_z2++;
212  }
213  }
214 }
215 
216 void
218  std::vector<FilterChargeDeconvolution::DataPointInfoSp> &data_points_info)
219  const
220 {
221  for(DataPointInfoSp &data_point_info : data_points_info)
222  {
223  if(data_point_info.get()->z1_vect.size() >= 1 &&
224  data_point_info.get()->z2_vect.size() == 0)
225  {
226  for(DataPointInfoSp other : data_point_info.get()->z1_vect)
227  {
228  other->z_charge = 1;
229  }
230  data_point_info.get()->z_charge = 1;
231  }
232  else if(data_point_info.get()->z1_vect.size() == 0 &&
233  data_point_info.get()->z2_vect.size() >= 1)
234  {
235  for(DataPointInfoSp other : data_point_info.get()->z2_vect)
236  {
237  other->z_charge = 2;
238  }
239  data_point_info.get()->z_charge = 2;
240  }
241  else if(data_point_info.get()->z1_vect.size() >= 1 &&
242  data_point_info.get()->z2_vect.size() >= 1)
243  {
244  for(DataPointInfoSp other : data_point_info.get()->z2_vect)
245  {
246  other->z_charge = 2;
247  }
248  data_point_info.get()->z_charge = 2;
249  }
250  else
251  {
252  if(data_point_info.get()->z_charge == -1)
253  {
254  data_point_info.get()->z_charge = 0;
255  }
256  }
257  }
258 }
259 
260 void
262  std::vector<FilterChargeDeconvolution::DataPointInfoSp> &data_points_info)
263  const
264 {
265  std::vector<FilterChargeDeconvolution::DataPointInfoSp>
266  deconvoluted_points_info;
267 
268  for(DataPointInfoSp &data_point_info : data_points_info)
269  {
270  if(data_point_info->parent == nullptr)
271  {
272  DataPointInfoSp deconvoluted_point(std::make_shared<DataPointInfo>());
273 
274  deconvoluted_point->z_charge = data_point_info->z_charge;
275  deconvoluted_point->new_mono_charge_data_point =
276  data_point_info->data_point;
277 
278  if(data_point_info->z_charge == 1)
279  {
280 
281  for(DataPointInfoSp data : data_point_info->z1_vect)
282  {
283  deconvoluted_point->new_mono_charge_data_point.y +=
284  data->data_point.y;
285  }
286  }
287  else if(data_point_info->z_charge == 2)
288  {
289  for(DataPointInfoSp data : data_point_info->z2_vect)
290  {
291  deconvoluted_point->new_mono_charge_data_point.y +=
292  data->data_point.y;
293  }
294  }
295  else // if z.charge == 0
296  {
297  deconvoluted_point->new_mono_charge_data_point =
298  data_point_info->data_point;
299  }
300  deconvoluted_points_info.push_back(deconvoluted_point);
301  }
302  }
303  data_points_info = deconvoluted_points_info;
304 }
305 
306 void
308  std::vector<FilterChargeDeconvolution::DataPointInfoSp> &data_points_info)
309  const
310 {
311  for(DataPointInfoSp &dpi : data_points_info)
312  {
313  if(dpi->z_charge == 2)
314  {
315  dpi->new_mono_charge_data_point.x +=
316  dpi->new_mono_charge_data_point.x - MHPLUS;
317  }
318  }
319 }
pappso::FilterChargeDeconvolution::m_diffC12C13_z2
double m_diffC12C13_z2
Definition: filterchargedeconvolution.h:148
pappso::MzRange::lower
pappso_double lower() const
Definition: mzrange.h:72
pappso::FilterChargeDeconvolution::DataPointInfoSp
std::shared_ptr< DataPointInfo > DataPointInfoSp
Definition: filterchargedeconvolution.h:45
pappso::MHPLUS
const pappso_double MHPLUS(1.007276466879)
pappso::FilterChargeDeconvolution::addDataPointToList
void addDataPointToList(std::vector< FilterChargeDeconvolution::DataPointInfoSp > &points, DataPoint &data_point) const
Add each datapoint to a vector of structure describe above.
Definition: filterchargedeconvolution.cpp:147
pappso::PrecisionFactory::getPrecisionPtrFractionInstance
static PrecisionPtr getPrecisionPtrFractionInstance(PrecisionPtr origin, double fraction)
get the fraction of an existing precision pointer
Definition: precision.cpp:202
pappso::MzRange::upper
pappso_double upper() const
Definition: mzrange.h:78
pappso
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition: aa.cpp:39
pappso::FilterChargeDeconvolution::FilterChargeDeconvolution
FilterChargeDeconvolution(PrecisionPtr precision_ptr)
Definition: filterchargedeconvolution.cpp:40
pappso::DataPoint
Definition: datapoint.h:21
pappso::FilterChargeDeconvolution::transformToMonoChargedForAllDataPoint
void transformToMonoChargedForAllDataPoint(std::vector< FilterChargeDeconvolution::DataPointInfoSp > &data_points_info) const
For eache datapointInfo with a charge = 2 transform the peak to a charge = 1 by multiplying the mz by...
Definition: filterchargedeconvolution.cpp:307
pappso::Trace::sortY
void sortY()
Definition: trace.cpp:800
pappso::FilterChargeDeconvolution::m_precisionPtrZ2
PrecisionPtr m_precisionPtrZ2
Definition: filterchargedeconvolution.h:150
pappso::MzRange
Definition: mzrange.h:46
pappso::Trace
A simple container of DataPoint instances.
Definition: trace.h:132
pappso::FilterChargeDeconvolution::m_precisionPtrZ1
PrecisionPtr m_precisionPtrZ1
Definition: filterchargedeconvolution.h:149
pappso::FilterChargeDeconvolution::m_diffC12C13_z1
double m_diffC12C13_z1
Definition: filterchargedeconvolution.h:147
pappso::ExceptionNotRecognized
excetion to use when an item type is not recognized
Definition: exceptionnotrecognized.h:42
pappso::DIFFC12C13
const pappso_double DIFFC12C13(1.0033548378)
pappso::PrecisionBase::getNominal
virtual pappso_double getNominal() const final
Definition: precision.cpp:64
pappso::DataPoint::x
pappso_double x
Definition: datapoint.h:22
pappso::FilterChargeDeconvolution::toString
QString toString() const override
Definition: filterchargedeconvolution.cpp:105
pappso::Trace::sortX
void sortX()
Definition: trace.cpp:792
pappso::FilterChargeDeconvolution::buildFilterFromString
void buildFilterFromString(const QString &strBuildParams) override
build this filer using a string
Definition: filterchargedeconvolution.cpp:69
pappso::FilterChargeDeconvolution::computeBestChargeOfDataPoint
void computeBestChargeOfDataPoint(std::vector< FilterChargeDeconvolution::DataPointInfoSp > &data_points_info) const
Compare both list (z1 and z2) and add the right level of charge.
Definition: filterchargedeconvolution.cpp:217
pappso::PrecisionBase
Definition: precision.h:44
pappso::FilterChargeDeconvolution::~FilterChargeDeconvolution
virtual ~FilterChargeDeconvolution()
Definition: filterchargedeconvolution.cpp:63
pappso::FilterChargeDeconvolution::addDataPointRefByExclusion
void addDataPointRefByExclusion(std::vector< FilterChargeDeconvolution::DataPointInfoSp > &points, FilterChargeDeconvolution::DataPointInfoSp &new_dpi) const
For eache datapointInfo add the datapoint to the lists by their exclusion range.
Definition: filterchargedeconvolution.cpp:163
pappso::FilterChargeDeconvolution::computeIsotopeDeconvolution
void computeIsotopeDeconvolution(std::vector< FilterChargeDeconvolution::DataPointInfoSp > &data_points_info) const
For eache datapointInfo whith no parent copy info in new vector with the intensity of the monoistipic...
Definition: filterchargedeconvolution.cpp:261
filterchargedeconvolution.h
Sum peaks and transform mz to fit charge = 1.
pappso::FilterChargeDeconvolution::filter
Trace & filter(Trace &data_points) const override
get all the datapoints and remove different isotope and add their intensity and change to charge = 1 ...
Definition: filterchargedeconvolution.cpp:115
pappso::PrecisionFactory::fromString
static PrecisionPtr fromString(const QString &str)
get a precision pointer from a string
Definition: precision.cpp:71
pappso::FilterChargeDeconvolution
Definition: filterchargedeconvolution.h:43