libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
timsframebase.h
Go to the documentation of this file.
1/**
2 * \file pappsomspp/vendors/tims/timsframebase.h
3 * \date 16/12/2019
4 * \author Olivier Langella
5 * \brief handle a single Bruker's TimsTof frame without binary data
6 */
7
8/*******************************************************************************
9 * Copyright (c) 2019 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 ******************************************************************************/
27
28#pragma once
29
30#include <memory>
31#include <vector>
32#include <QtGlobal>
33#include "../../massspectrum/massspectrum.h"
35
36namespace pappso
37{
38
39class TimsFrameBase;
40typedef std::shared_ptr<TimsFrameBase> TimsFrameBaseSPtr;
41typedef std::shared_ptr<const TimsFrameBase> TimsFrameBaseCstSPtr;
42
43
44/**
45 * @todo write docs
46 */
48{
49 public:
50 /** @brief constructor for binary independant tims frame
51 * @param timsId tims frame identifier in the database
52 * @param scanNum the total number of scans contained in this frame
53 */
54 TimsFrameBase(std::size_t timsId, quint32 scanNum);
55 /**
56 * Copy constructor
57 *
58 * @param other TODO
59 */
60 TimsFrameBase(const TimsFrameBase &other);
61
62 /**
63 * Destructor
64 */
65 virtual ~TimsFrameBase();
66
67 /** @brief tells if 2 tims frame has the same calibration data
68 * Usefull to know if raw data can be handled between frames
69 */
70 virtual bool hasSameCalibrationData(const TimsFrameBase &other) const;
71
72 /** @brief get the number of peaks in this spectrum
73 * need the binary file
74 * @param scanNum scan number in the frame in the order it lies in binary
75 * file, from 0 to N-1
76 */
77 virtual std::size_t getNbrPeaks(std::size_t scanNum) const;
78
79 /** @brief get the number of scans contained in this frame
80 * each scan represents an ion mobility slice
81 */
82
83 virtual std::size_t getTotalNumberOfScans() const;
84
85
86 /** @brief get the maximum raw mass index contained in this frame
87 */
88 virtual quint32 getMaximumRawMassIndex() const;
89
90 /** @brief get Mass spectrum with peaks for this scan number
91 * need the binary file
92 * @param scanNum scan number in the frame in the order it lies in binary
93 * file, from 0 to N-1
94 */
95 virtual MassSpectrumSPtr getMassSpectrumSPtr(std::size_t scanNum) const;
96
97 /** @brief cumulate spectrum given a scan number range
98 * need the binary file
99 * The intensities are normalized with respect to the frame accumulation time
100 *
101 * @param scanNumBegin scan number in the frame in the order it lies in binary
102 * file, from 0 to N-1
103 * @param scanNumEnd scan number in the frame in the order it lies in binary
104 * file, from 0 to N-1
105 */
106 virtual Trace cumulateScansToTrace(std::size_t scanNumBegin,
107 std::size_t scanNumEnd) const;
108
109
110 /** @brief cumulate spectrum given a scan number range
111 * need the binary file
112 * The intensities are normalized with respect to the frame accumulation time
113 * to leverage computing performance, this function decreases the mz
114 * resolution
115 *
116 * @param mzindex_merge_window width of the mzindex window used to merge all
117 * intensities into a single point. This results in faster computing.
118 * @param scanNumBegin scan number in the frame in the order it lies in binary
119 * file, from 0 to N-1
120 * @param scanNumEnd scan number in the frame in the order it lies in binary
121 * file, from 0 to N-1
122 */
123 virtual Trace
124 cumulateScansToTraceMzDownResolution(std::size_t mzindex_merge_window,
125 std::size_t scanNumBegin,
126 std::size_t scanNumEnd,
127 quint32 &minimum_index,
128 quint32 &maximum_index) const;
129
130
131 /** @brief downsize mz resolution to lower the number of real mz computations
132 *
133 * @param mzindex_merge_window width of the mzindex window used to merge all
134 * intensities into a single point. This results in faster computing.
135 * @param rawSpectrum the spectrum to shrink
136 */
137 std::map<quint32, quint32> &
138 downsizeMzRawMap(std::size_t mzindex_merge_window,
139 std::map<quint32, quint32> &rawSpectrum) const;
140
141 /** @brief cumulate scan list into a trace into a raw spectrum map
142 * The intensities are NOT normalized with respect to the frame accumulation
143 * time
144 *
145 * @param rawSpectrum simple map of integers to cumulate raw counts
146 * @param scanNumBegin scan number in the frame in the order it lies in binary
147 * file, from 0 to N-1
148 * @param scanNumEnd scan number in the frame in the order it lies in binary
149 * file, from 0 to N-1
150 */
151 virtual void cumulateScansInRawMap(std::map<quint32, quint32> &rawSpectrum,
152 std::size_t scanNumBegin,
153 std::size_t scanNumEnd) const;
154
155
156 virtual quint64 cumulateSingleScanIntensities(std::size_t scanNum) const;
157
158 virtual quint64 cumulateScansIntensities(std::size_t scanNumBegin,
159 std::size_t scanNumEnd) const;
160
161 /** @brief check that this scan number exists
162 * @param scanNum scan number in the frame in the order it lies in binary
163 * file, from 0 to N-1
164 */
165 bool checkScanNum(std::size_t scanNum) const;
166
167
168 void setAccumulationTime(double accumulation_time_ms);
169 void setMzCalibration(double T1_frame,
170 double T2_frame,
171 double digitizerTimebase,
172 double digitizerDelay,
173 double C0,
174 double C1,
175 double C2,
176 double C3,
177 double C4,
178 double T1_ref,
179 double T2_ref,
180 double dC1,
181 double dC2);
182 void setTimsCalibration(int tims_model_type,
183 double C0,
184 double C1,
185 double C2,
186 double C3,
187 double C4,
188 double C5,
189 double C6,
190 double C7,
191 double C8,
192 double C9);
193 void setTime(double time);
194 void setMsMsType(quint8 type);
195 unsigned int getMsLevel() const;
196 double getTime() const;
197
198 std::size_t getId() const;
199
200 /** @brief get drift time of a scan number in milliseconds
201 * @param scanNum scan number in the frame in the order it lies in binary
202 * file, from 0 to N-1
203 * @return time in milliseconds of mobility delay (drift time)
204 * */
205 double getDriftTime(std::size_t scanNum) const;
206
207 /** @brief get 1/K0 value of a given scan (mobility value)
208 * @param scanNum scan number in the frame in the order it lies in binary
209 * file, from 0 to N-1
210 * */
211 double getOneOverK0Transformation(std::size_t scanNum) const;
212
213
214 /** @brief get the scan number from a given 1/Ko mobility value
215 * @param one_over_k0 the mobility value to tranform
216 * @return integer the scan number in the frame in the order it lies in binary
217 * file, from 0 to N-1
218 */
219 std::size_t getScanNumFromOneOverK0(double one_over_k0) const;
220
221 /** @brief get voltage for a given scan number
222 * @param scanNum scan number in the frame in the order it lies in binary
223 * file, from 0 to N-1
224 * @return double volt measure
225 * */
226 double getVoltageTransformation(std::size_t scanNum) const;
227
228
229 /** @brief transform accumulation of raw scans into a real mass spectrum
230 */
232 std::map<quint32, quint32> &accumulated_scans) const;
233
234 /** @brief transform accumulation of raw scans into a real mass spectrum with
235 * a simple centroid on raw integers
236 */
238 std::map<quint32, quint32> &accumulated_scans) const;
239
240 /** @brief get the MzCalibration model to compute mz and TOF for this frame
241 */
242 virtual const MzCalibrationInterfaceSPtr &
243 getMzCalibrationInterfaceSPtr() const final;
244
246
247
248 /** @brief get raw index list for one given scan
249 * index are not TOF nor m/z, just index on digitizer
250 */
251 virtual std::vector<quint32> getScanIndexList(std::size_t scanNum) const;
252
253 /** @brief get raw intensities without transformation from one scan
254 * it needs intensity normalization
255 */
256 virtual std::vector<quint32> getScanIntensities(std::size_t scanNum) const;
257
258 /** @brief get a mobility trace cumulating intensities inside the given mass
259 * index range
260 * @param mz_index_lower_bound raw mass index lower bound
261 * @param mz_index_upper_bound raw mass index upper bound
262 * @param method max or sum intensities
263 */
264 virtual Trace
265 getIonMobilityTraceByMzIndexRange(std::size_t mz_index_lower_bound,
266 std::size_t mz_index_upper_bound,
267 XicExtractMethod method) const;
268
269
270 protected:
271 /** @brief total number of scans contained in this frame
272 */
274
275 /** @brief Tims frame database id (the SQL identifier of this frame)
276 * @warning in sqlite, there is another field called TimsId : this is not
277 * that, because it is in fact an offset in bytes in the binary file.
278 * */
279 std::size_t m_timsId;
280
281 /** @brief accumulation time in milliseconds
282 */
284
285 quint8 m_msMsType = 0;
286
287 /** @brief retention time
288 */
289 double m_time = 0;
290
291 double m_timsDvStart = 0; // C2 from TimsCalibration
292 double m_timsSlope =
293 0; // (dv_end - dv_start) / ncycles //C3 from TimsCalibration // C2 from
294 // TimsCalibration // C1 from TimsCalibration
295 double m_timsTtrans = 0; // C4 from TimsCalibration
296 double m_timsNdelay = 0; // C0 from TimsCalibration
297 double m_timsVmin = 0; // C8 from TimsCalibration
298 double m_timsVmax = 0; // C9 from TimsCalibration
299 double m_timsC6 = 0;
300 double m_timsC7 = 0;
301
303};
304} // namespace pappso
double m_accumulationTime
accumulation time in milliseconds
virtual quint64 cumulateSingleScanIntensities(std::size_t scanNum) const
double getVoltageTransformation(std::size_t scanNum) const
get voltage for a given scan number
virtual std::size_t getTotalNumberOfScans() const
get the number of scans contained in this frame each scan represents an ion mobility slice
virtual Trace getIonMobilityTraceByMzIndexRange(std::size_t mz_index_lower_bound, std::size_t mz_index_upper_bound, XicExtractMethod method) const
get a mobility trace cumulating intensities inside the given mass index range
virtual std::size_t getNbrPeaks(std::size_t scanNum) const
get the number of peaks in this spectrum need the binary file
std::map< quint32, quint32 > & downsizeMzRawMap(std::size_t mzindex_merge_window, std::map< quint32, quint32 > &rawSpectrum) const
downsize mz resolution to lower the number of real mz computations
MzCalibrationInterfaceSPtr msp_mzCalibration
virtual MassSpectrumSPtr getMassSpectrumSPtr(std::size_t scanNum) const
get Mass spectrum with peaks for this scan number need the binary file
virtual std::vector< quint32 > getScanIndexList(std::size_t scanNum) const
get raw index list for one given scan index are not TOF nor m/z, just index on digitizer
double getDriftTime(std::size_t scanNum) const
get drift time of a scan number in milliseconds
pappso::Trace getTraceFromCumulatedScansBuiltinCentroid(std::map< quint32, quint32 > &accumulated_scans) const
transform accumulation of raw scans into a real mass spectrum with a simple centroid on raw integers
double m_time
retention time
virtual quint64 cumulateScansIntensities(std::size_t scanNumBegin, std::size_t scanNumEnd) const
void setAccumulationTime(double accumulation_time_ms)
quint32 m_scanNumber
total number of scans contained in this frame
virtual void cumulateScansInRawMap(std::map< quint32, quint32 > &rawSpectrum, std::size_t scanNumBegin, std::size_t scanNumEnd) const
cumulate scan list into a trace into a raw spectrum map The intensities are NOT normalized with respe...
void setTime(double time)
std::size_t m_timsId
Tims frame database id (the SQL identifier of this frame)
pappso::Trace getTraceFromCumulatedScans(std::map< quint32, quint32 > &accumulated_scans) const
transform accumulation of raw scans into a real mass spectrum
virtual bool hasSameCalibrationData(const TimsFrameBase &other) const
tells if 2 tims frame has the same calibration data Usefull to know if raw data can be handled betwee...
virtual quint32 getMaximumRawMassIndex() const
get the maximum raw mass index contained in this frame
unsigned int getMsLevel() const
void setTimsCalibration(int tims_model_type, double C0, double C1, double C2, double C3, double C4, double C5, double C6, double C7, double C8, double C9)
virtual const MzCalibrationInterfaceSPtr & getMzCalibrationInterfaceSPtr() const final
get the MzCalibration model to compute mz and TOF for this frame
virtual Trace cumulateScansToTraceMzDownResolution(std::size_t mzindex_merge_window, std::size_t scanNumBegin, std::size_t scanNumEnd, quint32 &minimum_index, quint32 &maximum_index) const
cumulate spectrum given a scan number range need the binary file The intensities are normalized with ...
std::size_t getScanNumFromOneOverK0(double one_over_k0) const
get the scan number from a given 1/Ko mobility value
virtual Trace cumulateScansToTrace(std::size_t scanNumBegin, std::size_t scanNumEnd) const
cumulate spectrum given a scan number range need the binary file The intensities are normalized with ...
void setMsMsType(quint8 type)
void setMzCalibration(double T1_frame, double T2_frame, double digitizerTimebase, double digitizerDelay, double C0, double C1, double C2, double C3, double C4, double T1_ref, double T2_ref, double dC1, double dC2)
double getOneOverK0Transformation(std::size_t scanNum) const
get 1/K0 value of a given scan (mobility value)
bool checkScanNum(std::size_t scanNum) const
check that this scan number exists
void setMzCalibrationInterfaceSPtr(MzCalibrationInterfaceSPtr mzCalibration)
std::size_t getId() const
virtual std::vector< quint32 > getScanIntensities(std::size_t scanNum) const
get raw intensities without transformation from one scan it needs intensity normalization
A simple container of DataPoint instances.
Definition trace.h:148
handles different ways to compute m/z using calibration parameters
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
std::shared_ptr< const TimsFrameBase > TimsFrameBaseCstSPtr
std::shared_ptr< TimsFrameBase > TimsFrameBaseSPtr
std::shared_ptr< MzCalibrationInterface > MzCalibrationInterfaceSPtr
std::shared_ptr< MassSpectrum > MassSpectrumSPtr
XicExtractMethod
Definition types.h:240