libpappsomspp
Library for mass spectrometry
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 
36 namespace pappso
37 {
38 
39 class TimsFrameBase;
40 typedef std::shared_ptr<TimsFrameBase> TimsFrameBaseSPtr;
41 typedef 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  */
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 cumulateScanToTrace(std::size_t scanNumBegin,
107  std::size_t scanNumEnd) const;
108 
109 
110  /** @brief cumulate scan list into a trace into a raw spectrum map
111  * The intensities are NOT normalized with respect to the frame accumulation
112  * time
113  *
114  * @param rawSpectrum simple map of integers to cumulate raw counts
115  * @param scanNumBegin scan number in the frame in the order it lies in binary
116  * file, from 0 to N-1
117  * @param scanNumEnd scan number in the frame in the order it lies in binary
118  * file, from 0 to N-1
119  */
120  virtual void cumulateScansInRawMap(std::map<quint32, quint32> &rawSpectrum,
121  std::size_t scanNumBegin,
122  std::size_t scanNumEnd) const;
123 
124  virtual quint64 cumulateSingleScanIntensities(std::size_t scanNum) const;
125 
126  virtual quint64 cumulateScansIntensities(std::size_t scanNumBegin,
127  std::size_t scanNumEnd) const;
128 
129  /** @brief check that this scan number exists
130  * @param scanNum scan number in the frame in the order it lies in binary
131  * file, from 0 to N-1
132  */
133  bool checkScanNum(std::size_t scanNum) const;
134 
135 
136  void setAccumulationTime(double accumulation_time_ms);
137  void setMzCalibration(double T1_frame,
138  double T2_frame,
139  double digitizerTimebase,
140  double digitizerDelay,
141  double C0,
142  double C1,
143  double C2,
144  double C3,
145  double C4,
146  double T1_ref,
147  double T2_ref,
148  double dC1,
149  double dC2);
150  void setTimsCalibration(int tims_model_type,
151  double C0,
152  double C1,
153  double C2,
154  double C3,
155  double C4,
156  double C5,
157  double C6,
158  double C7,
159  double C8,
160  double C9);
161  void setTime(double time);
162  void setMsMsType(quint8 type);
163  unsigned int getMsLevel() const;
164  double getTime() const;
165 
166  std::size_t getId() const;
167 
168  /** @brief get drift time of a scan number in milliseconds
169  * @param scanNum scan number in the frame in the order it lies in binary
170  * file, from 0 to N-1
171  * @return time in milliseconds of mobility delay (drift time)
172  * */
173  double getDriftTime(std::size_t scanNum) const;
174 
175  /** @brief get 1/K0 value of a given scan (mobility value)
176  * @param scanNum scan number in the frame in the order it lies in binary
177  * file, from 0 to N-1
178  * */
179  double getOneOverK0Transformation(std::size_t scanNum) const;
180 
181 
182  /** @brief get the scan number from a given 1/Ko mobility value
183  * @param one_over_k0 the mobility value to tranform
184  * @return integer the scan number in the frame in the order it lies in binary
185  * file, from 0 to N-1
186  */
187  std::size_t getScanNumFromOneOverK0(double one_over_k0) const;
188 
189  /** @brief get voltage for a given scan number
190  * @param scanNum scan number in the frame in the order it lies in binary
191  * file, from 0 to N-1
192  * @return double volt measure
193  * */
194  double getVoltageTransformation(std::size_t scanNum) const;
195 
196 
197  /** @brief transform accumulation of raw scans into a real mass spectrum
198  */
200  std::map<quint32, quint32> &accumulated_scans) const;
201 
202  /** @brief transform accumulation of raw scans into a real mass spectrum with
203  * a simple centroid on raw integers
204  */
206  std::map<quint32, quint32> &accumulated_scans) const;
207 
208  /** @brief get the MzCalibration model to compute mz and TOF for this frame
209  */
210  virtual const MzCalibrationInterfaceSPtr &
211  getMzCalibrationInterfaceSPtr() const final;
212 
214 
215 
216  /** @brief get raw index list for one given scan
217  * index are not TOF nor m/z, just index on digitizer
218  */
219  virtual std::vector<quint32> getScanIndexList(std::size_t scanNum) const;
220 
221  /** @brief get raw intensities without transformation from one scan
222  * it needs intensity normalization
223  */
224  virtual std::vector<quint32> getScanIntensities(std::size_t scanNum) const;
225 
226  /** @brief get a mobility trace cumulating intensities inside the given mass
227  * index range
228  * @param mz_index_lower_bound raw mass index lower bound
229  * @param mz_index_upper_bound raw mass index upper bound
230  * @param method max or sum intensities
231  */
232  virtual Trace
233  getIonMobilityTraceByMzIndexRange(std::size_t mz_index_lower_bound,
234  std::size_t mz_index_upper_bound,
235  XicExtractMethod method) const;
236 
237 
238  protected:
239  /** @brief total number of scans contained in this frame
240  */
241  quint32 m_scanNumber;
242 
243  /** @brief Tims frame database id (the SQL identifier of this frame)
244  * @warning in sqlite, there is another field called TimsId : this is not
245  * that, because it is in fact an offset in bytes in the binary file.
246  * */
247  std::size_t m_timsId;
248 
249  /** @brief accumulation time in milliseconds
250  */
251  double m_accumulationTime = 0;
252 
253  quint8 m_msMsType = 0;
254 
255  /** @brief retention time
256  */
257  double m_time = 0;
258 
259  double m_timsDvStart = 0; // C2 from TimsCalibration
260  double m_timsSlope =
261  0; // (dv_end - dv_start) / ncycles //C3 from TimsCalibration // C2 from
262  // TimsCalibration // C1 from TimsCalibration
263  double m_timsTtrans = 0; // C4 from TimsCalibration
264  double m_timsNdelay = 0; // C0 from TimsCalibration
265  double m_timsVmin = 0; // C8 from TimsCalibration
266  double m_timsVmax = 0; // C9 from TimsCalibration
267  double m_timsC6 = 0;
268  double m_timsC7 = 0;
269 
271 };
272 } // namespace pappso
double m_accumulationTime
accumulation time in milliseconds
TimsFrameBase(const TimsFrameBase &other)
double getTime() const
virtual quint64 cumulateSingleScanIntensities(std::size_t scanNum) const
double getVoltageTransformation(std::size_t scanNum) const
get voltage for a given scan number
virtual Trace cumulateScanToTrace(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 ...
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
MzCalibrationInterfaceSPtr msp_mzCalibration
virtual MassSpectrumSPtr getMassSpectrumSPtr(std::size_t scanNum) const
get Mass spectrum with peaks for this scan number need the binary file
TimsFrameBase(std::size_t timsId, quint32 scanNum)
constructor for binary independant tims frame
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
std::size_t getScanNumFromOneOverK0(double one_over_k0) const
get the scan number from a given 1/Ko mobility value
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
Definition: timsframebase.h:41
std::shared_ptr< TimsFrameBase > TimsFrameBaseSPtr
Definition: timsframebase.h:39
std::shared_ptr< MzCalibrationInterface > MzCalibrationInterfaceSPtr
std::shared_ptr< MassSpectrum > MassSpectrumSPtr
Definition: massspectrum.h:54
XicExtractMethod
Definition: types.h:201