libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
timsdatafastmap.cpp
Go to the documentation of this file.
1/**
2 * \file pappsomspp/vendors/tims/timsdatafastmap.h
3 * \date 16/12/2023
4 * \author Olivier Langella
5 * \brief replacement fot std::map dedicated to tims data for fast computations
6 */
7
8/*******************************************************************************
9 * Copyright (c) 2023 Olivier Langella
10 *<Olivier.Langella@universite-paris-saclay.fr>.
11 *
12 * This file is part of the PAPPSOms++ library.
13 *
14 * PAPPSOms++ is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation, either version 3 of the License, or
17 * (at your option) any later version.
18 *
19 * PAPPSOms++ is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with PAPPSOms++. If not, see <http://www.gnu.org/licenses/>.
26 *
27 ******************************************************************************/
28
29#include "timsdatafastmap.h"
30#include <QDebug>
31
32namespace pappso
33{
34
35
36std::map<QThread *, TimsDataFastMap>
38
41{
42
44 {QThread::currentThread(), TimsDataFastMap()});
45
46 if(it.second)
47 {
48 it.first->second.mapTofIndexIntensity.resize(500000);
49 }
50 return it.first->second;
51}
52
54{
55 // map.resize(500000);
56}
57
58std::size_t
59TimsDataFastMap::accumulateIntensity(quint32 key, std::size_t intensity)
60{
61 TimsDataFastMapElement &map_element = mapTofIndexIntensity.at(key);
62 if(map_element.first_access)
63 {
64 map_element.first_access = false;
65 map_element.count = intensity;
66 tofIndexList.push_back(key);
67 }
68 else
69 {
70 map_element.count += intensity;
71 }
72 return map_element.count;
73}
74
75std::size_t
77{
78 TimsDataFastMapElement &map_element = mapTofIndexIntensity.at(key);
79 map_element.first_access = true;
80 return map_element.count;
81}
82
83void
84TimsDataFastMap::downsizeMzRawMap(std::size_t mzindex_merge_window)
85{
86 std::vector<std::pair<quint32, std::size_t>> temp_vector;
87 for(quint32 tof_index : tofIndexList)
88 {
89 temp_vector.push_back({tof_index, readIntensity(tof_index)});
90 }
91
92 tofIndexList.clear();
93
94 for(auto &pair_tof_intensity : temp_vector)
95 {
96
97 quint32 mzkey = (pair_tof_intensity.first / mzindex_merge_window);
98 mzkey = (mzkey * mzindex_merge_window) + (mzindex_merge_window / 2);
99
100 accumulateIntensity(mzkey, pair_tof_intensity.second);
101 }
102}
103
104void
106{
107 qDebug() << "tofIndexList.size()=" << tofIndexList.size();
108 if(tofIndexList.size() > 2)
109 {
110 std::vector<quint32> tof_index_list_tmp = tofIndexList;
111 std::sort(tof_index_list_tmp.begin(), tof_index_list_tmp.end());
112
113 tofIndexList.clear();
114
115 quint32 previous_tof_index = tof_index_list_tmp[0];
116 std::size_t previous_intensity = readIntensity(previous_tof_index);
117 for(std::size_t i = 1; i < tof_index_list_tmp.size(); i++)
118 {
119 quint32 tof_index = tof_index_list_tmp[i];
120 if(previous_tof_index == tof_index - 1)
121 {
122 std::size_t intensity = readIntensity(tof_index);
123 if(previous_intensity > intensity)
124 {
125 // flush writing current accumulated intensity
126 accumulateIntensity(previous_tof_index,
127 previous_intensity + intensity);
128 previous_intensity = 0;
129 previous_tof_index = tof_index;
130 }
131 else
132 {
133 // accumulate while intensity increases
134 previous_intensity += intensity;
135 previous_tof_index = tof_index;
136 }
137 }
138 else
139 {
140 // write accumulated intensity :
141 if(previous_intensity > 0)
142 {
143 // flush
144 accumulateIntensity(previous_tof_index, previous_intensity);
145 }
146 previous_tof_index = tof_index;
147 previous_intensity = readIntensity(tof_index);
148 }
149 }
150
151 // write remaining intensity :
152 if(previous_intensity > 0)
153 {
154 // flush
155 accumulateIntensity(previous_tof_index, previous_intensity);
156 }
157 }
158
159 qDebug() << "tofIndexList.size()=" << tofIndexList.size();
160}
161
162void
164{
165
166 std::vector<quint32> tof_index_list_tmp = tofIndexList;
167 tofIndexList.clear();
168 for(quint32 tof_index : tof_index_list_tmp)
169 {
170 if((tof_index > 0) && mapTofIndexIntensity[tof_index - 1].first_access &&
171 mapTofIndexIntensity[tof_index + 1].first_access &&
172 (mapTofIndexIntensity[tof_index].count == 10))
173 {
174 // this measure is too small and alone : remove it
175 mapTofIndexIntensity[tof_index].first_access = true;
176 }
177 else
178 {
179 tofIndexList.push_back(tof_index);
180 }
181 }
182}
183
184
185} // namespace pappso
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
replacement for std::map
std::size_t accumulateIntensity(quint32 tofIndex, std::size_t intensity)
accumulates intesity for the given tof index
void builtInCentroid()
simple filter to agregate counts on neigbhor mobility slots (+1)
static std::map< QThread *, TimsDataFastMap > m_preAllocatedFastaMapPerThread
std::size_t readIntensity(quint32)
reads intensity for a tof_index
std::vector< quint32 > tofIndexList
void downsizeMzRawMap(std::size_t mzindex_merge_window)
downsize mz resolution to lower the number of real mz computations
static TimsDataFastMap & getTimsDataFastMapInstance()
std::vector< TimsDataFastMapElement > mapTofIndexIntensity
replacement fot std::map dedicated to tims data for fast computations