libpappsomspp
Library for mass spectrometry
timsdata.cpp
Go to the documentation of this file.
1 /**
2  * \file pappsomspp/vendors/tims/timsdata.cpp
3  * \date 27/08/2019
4  * \author Olivier Langella
5  * \brief main Tims data handler
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 #include "timsdata.h"
29 #include "../../exception/exceptionnotfound.h"
30 #include "../../processing/combiners/tracepluscombiner.h"
31 #include "../../processing/filters/filtertriangle.h"
32 #include "../../processing/filters/filterpseudocentroid.h"
33 #include "../../processing/filters/filterpass.h"
35 #include <QDebug>
36 #include <solvers.h>
37 #include <QSqlError>
38 #include <QSqlQuery>
39 #include <QSqlRecord>
40 #include <QMutexLocker>
41 #include <QThread>
42 #include <set>
43 
44 using namespace pappso;
45 
46 TimsData::TimsData(QDir timsDataDirectory)
47  : m_timsDataDirectory(timsDataDirectory)
48 {
49 
50  qDebug();
52  if(!m_timsDataDirectory.exists())
53  {
54  throw PappsoException(
55  QObject::tr("ERROR TIMS data directory %1 not found")
56  .arg(m_timsDataDirectory.absolutePath()));
57  }
58 
59  if(!QFileInfo(m_timsDataDirectory.absoluteFilePath("analysis.tdf")).exists())
60  {
61 
62  throw PappsoException(
63  QObject::tr("ERROR TIMS data directory, %1 sqlite file not found")
64  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf")));
65  }
66 
67  // Open the database
68  QSqlDatabase qdb = openDatabaseConnection();
69 
70 
71  QSqlQuery q(qdb);
72  if(!q.exec("select Key, Value from GlobalMetadata where "
73  "Key='TimsCompressionType';"))
74  {
75 
76  qDebug();
77  throw PappsoException(
78  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
79  "command %2:\n%3\n%4\n%5")
80  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
81  .arg(q.lastQuery())
82  .arg(q.lastError().databaseText())
83  .arg(q.lastError().driverText())
84  .arg(q.lastError().nativeErrorCode()));
85  }
86 
87 
88  int compression_type = 0;
89  if(q.next())
90  {
91  compression_type = q.value(1).toInt();
92  }
93  qDebug() << " compression_type=" << compression_type;
95  QFileInfo(m_timsDataDirectory.absoluteFilePath("analysis.tdf_bin")),
96  compression_type);
97 
98 
99  // get number of precursors
100  if(!q.exec("SELECT COUNT( DISTINCT Id) FROM Precursors;"))
101  {
102  qDebug();
103  throw PappsoException(
104  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
105  "command %2:\n%3\n%4\n%5")
106  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
107  .arg(q.lastQuery())
108  .arg(qdb.lastError().databaseText())
109  .arg(qdb.lastError().driverText())
110  .arg(qdb.lastError().nativeErrorCode()));
111  }
112  if(q.next())
113  {
114  m_totalNumberOfPrecursors = q.value(0).toLongLong();
115  }
116 
117 
118  // get number of scans
119  if(!q.exec("SELECT SUM(NumScans) FROM Frames"))
120  {
121  qDebug();
122  throw PappsoException(
123  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
124  "command %2:\n%3\n%4\n%5")
125  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
126  .arg(q.lastQuery())
127  .arg(qdb.lastError().databaseText())
128  .arg(qdb.lastError().driverText())
129  .arg(qdb.lastError().nativeErrorCode()));
130  }
131  if(q.next())
132  {
133  m_totalNumberOfScans = q.value(0).toLongLong();
134  }
135 
136  if(!q.exec("select * from MzCalibration;"))
137  {
138  qDebug();
139  throw PappsoException(
140  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
141  "command %2:\n%3\n%4\n%5")
142  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
143  .arg(q.lastQuery())
144  .arg(q.lastError().databaseText())
145  .arg(q.lastError().driverText())
146  .arg(q.lastError().nativeErrorCode()));
147  }
148 
149  while(q.next())
150  {
151  QSqlRecord record = q.record();
153  std::pair<int, QSqlRecord>(record.value(0).toInt(), record));
154  }
155 
156  std::shared_ptr<pappso::FilterPseudoCentroid> ms2filter =
157  std::make_shared<pappso::FilterPseudoCentroid>(35000, 5, 0.5, 0.1);
158  mcsp_ms2Filter = ms2filter;
159 
160 
161  std::shared_ptr<FilterTriangle> ms1filter =
162  std::make_shared<FilterTriangle>();
163  ms1filter.get()->setTriangleSlope(50, 0.01);
164  mcsp_ms1Filter = ms1filter;
165 }
166 
167 QSqlDatabase
169 {
170  QString database_connection_name = QString("%1_%2")
171  .arg(m_timsDataDirectory.absolutePath())
172  .arg((quintptr)QThread::currentThread());
173  // Open the database
174  QSqlDatabase qdb = QSqlDatabase::database(database_connection_name);
175  if(!qdb.isValid())
176  {
177  qDebug() << database_connection_name;
178  qdb = QSqlDatabase::addDatabase("QSQLITE", database_connection_name);
179  qdb.setDatabaseName(m_timsDataDirectory.absoluteFilePath("analysis.tdf"));
180  }
181 
182 
183  if(!qdb.open())
184  {
185  qDebug();
186  throw PappsoException(
187  QObject::tr("ERROR opening TIMS sqlite database file %1, database name "
188  "%2 :\n%3\n%4\n%5")
189  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
190  .arg(database_connection_name)
191  .arg(qdb.lastError().databaseText())
192  .arg(qdb.lastError().driverText())
193  .arg(qdb.lastError().nativeErrorCode()));
194  }
195  return qdb;
196 }
197 
198 TimsData::TimsData([[maybe_unused]] const pappso::TimsData &other)
199 {
200  qDebug();
201 }
202 
204 {
205  // m_qdb.close();
206  if(mpa_timsBinDec != nullptr)
207  {
208  delete mpa_timsBinDec;
209  }
210 }
211 
212 void
214 {
215  m_builtinMs2Centroid = centroid;
216 }
217 
218 bool
220 {
221  return m_builtinMs2Centroid;
222 }
223 
224 std::pair<std::size_t, std::size_t>
225 TimsData::getScanCoordinateFromRawIndex(std::size_t raw_index) const
226 {
227 
228  QSqlDatabase qdb = openDatabaseConnection();
229 
230  QSqlQuery q =
231  qdb.exec(QString("SELECT Id, NumScans FROM "
232  "Frames ORDER BY Id"));
233  if(q.lastError().isValid())
234  {
235 
236  throw PappsoException(
237  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
238  "command %2:\n%3\n%4\n%5")
239  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
240  .arg(q.lastQuery())
241  .arg(qdb.lastError().databaseText())
242  .arg(qdb.lastError().driverText())
243  .arg(qdb.lastError().nativeErrorCode()));
244  }
245  pappso::TimsFrameSPtr tims_frame;
246  bool index_found = false;
247  std::size_t timsId;
248  std::size_t numberScans;
249  std::size_t offset = 0;
250  while(q.next() && (!index_found))
251  {
252  timsId = q.value(0).toUInt();
253  numberScans = q.value(1).toUInt();
254 
255  if(raw_index < (offset + numberScans))
256  {
257  return std::pair<std::size_t, std::size_t>(timsId,
258  raw_index - offset);
259  }
260 
261  offset += numberScans;
262  }
263 
264  throw ExceptionNotFound(
265  QObject::tr("ERROR raw index %1 not found").arg(raw_index));
266 }
267 
268 
269 std::size_t
271  std::size_t scan_num) const
272 {
273 
274 
275  QSqlDatabase qdb = openDatabaseConnection();
276  QSqlQuery q =
277  qdb.exec(QString("SELECT Id, NumScans FROM "
278  "Frames ORDER BY Id"));
279  if(q.lastError().isValid())
280  {
281 
282  throw PappsoException(
283  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
284  "command %2:\n%3\n%4\n%5")
285  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
286  .arg(q.lastQuery())
287  .arg(qdb.lastError().databaseText())
288  .arg(qdb.lastError().driverText())
289  .arg(qdb.lastError().nativeErrorCode()));
290  }
291  bool index_found = false;
292  std::size_t timsId;
293  std::size_t numberScans;
294  std::size_t offset = 0;
295  while(q.next() && (!index_found))
296  {
297  timsId = q.value(0).toUInt();
298  numberScans = q.value(1).toUInt();
299 
300  if(timsId == frame_id)
301  {
302  return offset + scan_num;
303  }
304 
305  offset += numberScans;
306  }
307 
308  throw ExceptionNotFound(
309  QObject::tr("ERROR raw index with frame=%1 scan=%2 not found")
310  .arg(frame_id)
311  .arg(scan_num));
312 }
313 
314 /** @brief get a mass spectrum given its spectrum index
315  * @param raw_index a number begining at 0, corresponding to a Tims Scan in
316  * the order they lies in the binary data file
317  */
320 {
321 
322  auto coordinate = getScanCoordinateFromRawIndex(raw_index);
323  return getMassSpectrumCstSPtr(coordinate.first, coordinate.second);
324 }
325 
326 
328 TimsData::getTimsFrameBaseCstSPtr(std::size_t timsId) const
329 {
330 
331  qDebug() << " timsId=" << timsId;
332 
333  QSqlDatabase qdb = openDatabaseConnection();
334  QSqlQuery q = qdb.exec(
335  QString("SELECT Frames.TimsId, Frames.AccumulationTime, " // 1
336  "Frames.MzCalibration, " // 2
337  "Frames.T1, Frames.T2, " // 4
338  "Frames.Time, Frames.MsMsType, TimsCalibration.ModelType, " // 7
339  "TimsCalibration.C0, TimsCalibration.C1, TimsCalibration.C2, " // 10
340  "TimsCalibration.C3, TimsCalibration.C4, TimsCalibration.C5, " // 13
341  "TimsCalibration.C6, TimsCalibration.C7, TimsCalibration.C8, " // 16
342  "TimsCalibration.C9 FROM Frames" // 17
343  " INNER JOIN TimsCalibration "
344  "ON Frames.TimsCalibration=TimsCalibration.Id where "
345  "Frames.Id=%1;")
346  .arg(timsId));
347  if(q.lastError().isValid())
348  {
349 
350  throw PappsoException(
351  QObject::tr("ERROR in TIMS sqlite database file %1, database name %2, "
352  "executing SQL "
353  "command %3:\n%4\n%5\n%6")
354  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
355  .arg(qdb.databaseName())
356  .arg(q.lastQuery())
357  .arg(qdb.lastError().databaseText())
358  .arg(qdb.lastError().driverText())
359  .arg(qdb.lastError().nativeErrorCode()));
360  }
361  pappso::TimsFrameBaseSPtr tims_frame;
362  if(q.next())
363  {
364 
365 
366  tims_frame = std::make_shared<TimsFrameBase>(
367  TimsFrameBase(timsId, q.value(0).toUInt()));
368 
369  auto it_map_record = m_mapMzCalibrationRecord.find(q.value(2).toInt());
370  if(it_map_record != m_mapMzCalibrationRecord.end())
371  {
372 
373  double T1_frame = q.value(3).toDouble(); // Frames.T1
374  double T2_frame = q.value(4).toDouble(); // Frames.T2
375 
376 
377  tims_frame.get()->setMzCalibrationInterfaceSPtr(
379  T1_frame, T2_frame, it_map_record->second));
380  }
381  else
382  {
383  throw ExceptionNotFound(
384  QObject::tr("ERROR MzCalibration database id %1 not found")
385  .arg(q.value(2).toInt()));
386  }
387 
388  tims_frame.get()->setAccumulationTime(q.value(1).toDouble());
389 
390  tims_frame.get()->setTime(q.value(5).toDouble());
391  tims_frame.get()->setMsMsType(q.value(6).toUInt());
392 
393  tims_frame.get()->setTimsCalibration(q.value(7).toInt(),
394  q.value(8).toDouble(),
395  q.value(9).toDouble(),
396  q.value(10).toDouble(),
397  q.value(11).toDouble(),
398  q.value(12).toDouble(),
399  q.value(13).toDouble(),
400  q.value(14).toDouble(),
401  q.value(15).toDouble(),
402  q.value(16).toDouble(),
403  q.value(17).toDouble());
404  return tims_frame;
405  }
406 
407  throw ExceptionNotFound(QObject::tr("ERROR timsId %1 not found").arg(timsId));
408  // return TimsFrameCstSPtr;
409 }
410 
411 std::vector<std::size_t>
412 TimsData::getTimsMS1FrameIdRange(double rt_begin, double rt_end) const
413 {
414 
415  qDebug() << " rt_begin=" << rt_begin << " rt_end=" << rt_end;
416  std::vector<std::size_t> tims_frameid_list;
417  QSqlDatabase qdb = openDatabaseConnection();
418  QSqlQuery q = qdb.exec(QString("SELECT Frames.TimsId FROM Frames WHERE "
419  "Frames.MsMsType=0 AND (Frames.Time=>%1) AND "
420  "(Frames.Time<=%2) SORT BY Frames.Time;")
421  .arg(rt_begin)
422  .arg(rt_end));
423  if(q.lastError().isValid())
424  {
425 
426  throw PappsoException(
427  QObject::tr("ERROR in TIMS sqlite database file %1, database name %2, "
428  "executing SQL "
429  "command %3:\n%4\n%5\n%6")
430  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
431  .arg(qdb.databaseName())
432  .arg(q.lastQuery())
433  .arg(qdb.lastError().databaseText())
434  .arg(qdb.lastError().driverText())
435  .arg(qdb.lastError().nativeErrorCode()));
436  }
437  while(q.next())
438  {
439 
440  tims_frameid_list.push_back(q.value(0).toUInt());
441  }
442  return tims_frameid_list;
443 }
444 
446 TimsData::getTimsFrameCstSPtr(std::size_t timsId) const
447 {
448 
449  qDebug() << " timsId=" << timsId;
450 
451  QSqlDatabase qdb = openDatabaseConnection();
452  QSqlQuery q = qdb.exec(
453  QString("SELECT Frames.TimsId, Frames.AccumulationTime, " // 1
454  "Frames.MzCalibration, " // 2
455  "Frames.T1, Frames.T2, " // 4
456  "Frames.Time, Frames.MsMsType, TimsCalibration.ModelType, " // 7
457  "TimsCalibration.C0, TimsCalibration.C1, TimsCalibration.C2, " // 10
458  "TimsCalibration.C3, TimsCalibration.C4, TimsCalibration.C5, " // 13
459  "TimsCalibration.C6, TimsCalibration.C7, TimsCalibration.C8, " // 16
460  "TimsCalibration.C9 FROM Frames" // 17
461  " INNER JOIN TimsCalibration "
462  "ON Frames.TimsCalibration=TimsCalibration.Id where "
463  "Frames.Id=%1;")
464  .arg(timsId));
465  if(q.lastError().isValid())
466  {
467 
468  throw PappsoException(
469  QObject::tr("ERROR in TIMS sqlite database file %1, database name %2, "
470  "executing SQL "
471  "command %3:\n%4\n%5\n%6")
472  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
473  .arg(qdb.databaseName())
474  .arg(q.lastQuery())
475  .arg(qdb.lastError().databaseText())
476  .arg(qdb.lastError().driverText())
477  .arg(qdb.lastError().nativeErrorCode()));
478  }
479  pappso::TimsFrameSPtr tims_frame;
480  if(q.next())
481  {
482 
483 
484  tims_frame =
485  mpa_timsBinDec->getTimsFrameSPtrByOffset(timsId, q.value(0).toUInt());
486 
487 
488  auto it_map_record = m_mapMzCalibrationRecord.find(q.value(2).toInt());
489  if(it_map_record != m_mapMzCalibrationRecord.end())
490  {
491 
492  double T1_frame = q.value(3).toDouble(); // Frames.T1
493  double T2_frame = q.value(4).toDouble(); // Frames.T2
494 
495 
496  tims_frame.get()->setMzCalibrationInterfaceSPtr(
498  T1_frame, T2_frame, it_map_record->second));
499  }
500  else
501  {
502  throw ExceptionNotFound(
503  QObject::tr("ERROR MzCalibration database id %1 not found")
504  .arg(q.value(2).toInt()));
505  }
506 
507  tims_frame.get()->setAccumulationTime(q.value(1).toDouble());
508 
509  tims_frame.get()->setTime(q.value(5).toDouble());
510  tims_frame.get()->setMsMsType(q.value(6).toUInt());
511 
512  tims_frame.get()->setTimsCalibration(q.value(7).toInt(),
513  q.value(8).toDouble(),
514  q.value(9).toDouble(),
515  q.value(10).toDouble(),
516  q.value(11).toDouble(),
517  q.value(12).toDouble(),
518  q.value(13).toDouble(),
519  q.value(14).toDouble(),
520  q.value(15).toDouble(),
521  q.value(16).toDouble(),
522  q.value(17).toDouble());
523  return tims_frame;
524  }
525 
526  throw ExceptionNotFound(QObject::tr("ERROR timsId %1 not found").arg(timsId));
527  // return TimsFrameCstSPtr;
528 }
529 
530 
532 TimsData::getMassSpectrumCstSPtr(std::size_t timsId, std::size_t scanNum)
533 {
535 
536  return frame->getMassSpectrumCstSPtr(scanNum);
537 }
538 
539 std::size_t
541 {
542  return m_totalNumberOfScans;
543 }
544 
545 
546 std::size_t
548 {
550 }
551 
552 std::vector<std::size_t>
554  double mz_val,
555  double rt_sec,
556  double k0)
557 {
558  std::vector<std::size_t> precursor_ids;
559  std::vector<std::vector<double>> ids;
560 
561  QSqlDatabase qdb = openDatabaseConnection();
562  QSqlQuery q = qdb.exec(
563  QString(
564  "SELECT Frames.time, Precursors.MonoisotopicMz, Precursors.Charge, "
565  "Precursors.Id, Frames.Id, PasefFrameMsMsInfo.ScanNumBegin, "
566  "PasefFrameMsMsInfo.scanNumEnd "
567  "FROM Frames "
568  "INNER JOIN PasefFrameMsMsInfo ON Frames.Id = PasefFrameMsMsInfo.Frame "
569  "INNER JOIN Precursors ON PasefFrameMsMsInfo.Precursor = Precursors.Id "
570  "WHERE Precursors.Charge == %1 "
571  "AND Precursors.MonoisotopicMz > %2 -0.01 "
572  "AND Precursors.MonoisotopicMz < %2 +0.01 "
573  "AND Frames.Time >= %3 "
574  "AND Frames.Time < %3 +1; ")
575  .arg(charge)
576  .arg(mz_val)
577  .arg(rt_sec));
578  if(q.lastError().isValid())
579  {
580 
581  throw PappsoException(
582  QObject::tr("ERROR in TIMS sqlite database file %1, database name %2, "
583  "executing SQL "
584  "command %3:\n%4\n%5\n%6")
585  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
586  .arg(qdb.databaseName())
587  .arg(q.lastQuery())
588  .arg(qdb.lastError().databaseText())
589  .arg(qdb.lastError().driverText())
590  .arg(qdb.lastError().nativeErrorCode()));
591  }
592  while(q.next())
593  {
594  qInfo() << q.value(0).toDouble() << q.value(1).toDouble()
595  << q.value(2).toDouble() << q.value(3).toDouble();
596 
597  std::vector<double> sql_values;
598  sql_values.push_back(q.value(4).toDouble()); // frame id
599  sql_values.push_back(q.value(3).toDouble()); // precursor id
600  sql_values.push_back(q.value(5).toDouble()); // scan num begin
601  sql_values.push_back(q.value(6).toDouble()); // scan num end
602  sql_values.push_back(q.value(1).toDouble()); // mz_value
603 
604  ids.push_back(sql_values);
605 
606 
607  if(std::find(precursor_ids.begin(),
608  precursor_ids.end(),
609  q.value(3).toDouble()) == precursor_ids.end())
610  {
611  precursor_ids.push_back(q.value(3).toDouble());
612  }
613  }
614 
615  if(precursor_ids.size() > 1)
616  {
617  // std::vector<std::size_t> precursor_ids_ko =
618  // getMatchPrecursorIdByKo(ids, values[3]);
619  if(precursor_ids.size() > 1)
620  {
621  precursor_ids = getClosestPrecursorIdByMz(ids, k0);
622  }
623  return precursor_ids;
624  }
625  else
626  {
627  return precursor_ids;
628  }
629 }
630 
631 std::vector<std::size_t>
632 TimsData::getMatchPrecursorIdByKo(std::vector<std::vector<double>> ids,
633  double ko_value)
634 {
635  std::vector<std::size_t> precursor_id;
636  for(std::vector<double> index : ids)
637  {
638  auto coordinate = getScanCoordinateFromRawIndex(index[0]);
639 
640  TimsFrameBaseCstSPtr tims_frame;
641  tims_frame = getTimsFrameBaseCstSPtrCached(coordinate.first);
642 
643  double bko = tims_frame.get()->getOneOverK0Transformation(index[2]);
644  double eko = tims_frame.get()->getOneOverK0Transformation(index[3]);
645 
646  qInfo() << "diff" << (bko + eko) / 2;
647  double mean_ko = (bko + eko) / 2;
648 
649  if(mean_ko > ko_value - 0.1 && mean_ko < ko_value + 0.1)
650  {
651  precursor_id.push_back(index[1]);
652  }
653  }
654  return precursor_id;
655 }
656 
657 std::vector<std::size_t>
658 TimsData::getClosestPrecursorIdByMz(std::vector<std::vector<double>> ids,
659  double mz_value)
660 {
661  std::vector<std::size_t> best_precursor;
662  double best_value = 1;
663  int count = 1;
664  int best_val_position = 0;
665 
666  for(std::vector<double> values : ids)
667  {
668  double new_val = abs(mz_value - values[4]);
669  if(new_val < best_value)
670  {
671  best_value = new_val;
672  best_val_position = count;
673  }
674  count++;
675  }
676  best_precursor.push_back(ids[best_val_position][1]);
677  return best_precursor;
678 }
679 
680 
681 unsigned int
682 TimsData::getMsLevelBySpectrumIndex(std::size_t spectrum_index)
683 {
684  auto coordinate = getScanCoordinateFromRawIndex(spectrum_index);
685  auto tims_frame = getTimsFrameCstSPtrCached(coordinate.first);
686  return tims_frame.get()->getMsLevel();
687 }
688 
689 
692  bool want_binary_data)
693 {
694  auto coordinate = getScanCoordinateFromRawIndex(spectrum_index);
695  TimsFrameBaseCstSPtr tims_frame;
696  if(want_binary_data)
697  {
698  tims_frame = getTimsFrameCstSPtrCached(coordinate.first);
699  }
700  else
701  {
702  tims_frame = getTimsFrameBaseCstSPtrCached(coordinate.first);
703  }
704  QualifiedMassSpectrum mass_spectrum;
705  MassSpectrumId spectrum_id;
706 
707  spectrum_id.setSpectrumIndex(spectrum_index);
708  spectrum_id.setNativeId(QString("frame=%1 scan=%2 index=%3")
709  .arg(coordinate.first)
710  .arg(coordinate.second)
711  .arg(spectrum_index));
712 
713  mass_spectrum.setMassSpectrumId(spectrum_id);
714 
715  mass_spectrum.setMsLevel(tims_frame.get()->getMsLevel());
716  mass_spectrum.setRtInSeconds(tims_frame.get()->getTime());
717 
718  mass_spectrum.setDtInMilliSeconds(
719  tims_frame.get()->getDriftTime(coordinate.second));
720  // 1/K0
721  mass_spectrum.setParameterValue(
722  QualifiedMassSpectrumParameter::OneOverK0,
723  tims_frame.get()->getOneOverK0Transformation(coordinate.second));
724 
725  mass_spectrum.setEmptyMassSpectrum(true);
726  if(want_binary_data)
727  {
728  mass_spectrum.setMassSpectrumSPtr(
729  tims_frame.get()->getMassSpectrumSPtr(coordinate.second));
730  if(mass_spectrum.size() > 0)
731  {
732  mass_spectrum.setEmptyMassSpectrum(false);
733  }
734  }
735  else
736  {
737  // if(tims_frame.get()->getNbrPeaks(coordinate.second) > 0)
738  //{
739  mass_spectrum.setEmptyMassSpectrum(false);
740  // }
741  }
742  if(tims_frame.get()->getMsLevel() > 1)
743  {
744 
745  QSqlDatabase qdb = openDatabaseConnection();
746  QSqlQuery q = qdb.exec(
747  QString(
748  "SELECT PasefFrameMsMsInfo.*, Precursors.* FROM "
749  "PasefFrameMsMsInfo INNER JOIN Precursors ON "
750  "PasefFrameMsMsInfo.Precursor=Precursors.Id where "
751  "PasefFrameMsMsInfo.Frame=%1 and (PasefFrameMsMsInfo.ScanNumBegin "
752  "<= %2 and PasefFrameMsMsInfo.ScanNumEnd >= %2);")
753  .arg(coordinate.first)
754  .arg(coordinate.second));
755  if(q.lastError().isValid())
756  {
757  throw PappsoException(
758  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
759  "command %2:\n%3\n%4\n%5")
760  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
761  .arg(q.lastQuery())
762  .arg(qdb.lastError().databaseText())
763  .arg(qdb.lastError().driverText())
764  .arg(qdb.lastError().nativeErrorCode()));
765  }
766  if(q.next())
767  {
768  // mass_spectrum.setPrecursorCharge(q.value(11).toInt());
769  // mass_spectrum.setPrecursorMz(q.value(10).toDouble());
770  // mass_spectrum.setPrecursorIntensity(q.value(13).toDouble());
771  // mass_spectrum.setPrecursorSpectrumIndex();
772 
773  mass_spectrum.appendPrecursorIonData(
774  PrecursorIonData(q.value(10).toDouble(),
775  q.value(11).toInt(),
776  q.value(13).toDouble()));
777 
778 
779  MassSpectrumId spectrum_id;
780  std::size_t prec_spectrum_index = getRawIndexFromCoordinate(
781  q.value(14).toDouble(), coordinate.second);
782 
783  mass_spectrum.setPrecursorSpectrumIndex(prec_spectrum_index);
784  mass_spectrum.setPrecursorNativeId(
785  QString("frame=%1 scan=%2 index=%3")
786  .arg(q.value(14).toDouble())
787  .arg(coordinate.second)
788  .arg(prec_spectrum_index));
789 
790  mass_spectrum.setParameterValue(
791  QualifiedMassSpectrumParameter::IsolationMz, q.value(3).toDouble());
792  mass_spectrum.setParameterValue(
793  QualifiedMassSpectrumParameter::IsolationWidth,
794  q.value(4).toDouble());
795 
796  mass_spectrum.setParameterValue(
797  QualifiedMassSpectrumParameter::CollisionEnergy,
798  q.value(5).toFloat());
799  mass_spectrum.setParameterValue(
800  QualifiedMassSpectrumParameter::BrukerPrecursorIndex,
801  q.value(6).toInt());
802  }
803  }
804 
805  return mass_spectrum;
806 }
807 
808 
811  std::size_t precursor_index,
812  bool want_binary_data)
813 {
814  QualifiedMassSpectrum mass_spectrum;
815 
816  try
817  {
818  QSqlDatabase qdb = openDatabaseConnection();
819  mass_spectrum.setMsLevel(1);
820  mass_spectrum.setPrecursorSpectrumIndex(0);
821  mass_spectrum.setEmptyMassSpectrum(true);
822  QSqlQuery q =
823  qdb.exec(QString("SELECT PasefFrameMsMsInfo.*, Precursors.* FROM "
824  "PasefFrameMsMsInfo INNER JOIN Precursors ON "
825  "PasefFrameMsMsInfo.Precursor=Precursors.Id where "
826  "Precursors.Id=%1;")
827  .arg(precursor_index));
828  if(q.lastError().isValid())
829  {
830 
831  throw PappsoException(
832  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
833  "command %2:\n%3\n%4\n%5")
834  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
835  .arg(q.lastQuery())
836  .arg(qdb.lastError().databaseText())
837  .arg(qdb.lastError().driverText())
838  .arg(qdb.lastError().nativeErrorCode()));
839  }
840  if(q.size() == 0)
841  {
842 
843  throw ExceptionNotFound(
844  QObject::tr(
845  "ERROR in getQualifiedMassSpectrumByPrecursorId, precursor "
846  "id=%1 not found")
847  .arg(precursor_index));
848  }
849  else
850  {
851  TracePlusCombiner combiner;
852  MapTrace combiner_result;
853 
854 
855  bool first = true;
856  std::size_t scan_mobility_start = 0;
857  std::size_t scan_mobility_end = 0;
858  std::set<std::size_t> tims_frame_list;
859  while(q.next())
860  {
861  // get MS1 frame
862  tims_frame_list.insert(q.value(14).toLongLong());
863  if(first)
864  {
865 
866 
867  MassSpectrumId spectrum_id;
868 
869  spectrum_id.setSpectrumIndex(precursor_index);
870  spectrum_id.setNativeId(
871  QString("frame=%1 begin=%2 end=%3 precursor=%4 idxms2=%5")
872  .arg(q.value(0).toLongLong())
873  .arg(q.value(1).toLongLong())
874  .arg(q.value(2).toLongLong())
875  .arg(precursor_index)
876  .arg(ms2_index));
877 
878 
879  mass_spectrum.setMassSpectrumId(spectrum_id);
880 
881 
882  scan_mobility_start = q.value(1).toLongLong();
883  scan_mobility_end = q.value(2).toLongLong();
884 
885  first = false;
886  }
887  }
888 
889  first = true;
890  for(std::size_t tims_id : tims_frame_list)
891  {
892  TimsFrameBaseCstSPtr tims_frame =
893  getTimsFrameCstSPtrCached(tims_id);
894  if(first)
895  {
896  mass_spectrum.setRtInSeconds(tims_frame.get()->getTime());
897 
898  mass_spectrum.setParameterValue(
899  QualifiedMassSpectrumParameter::OneOverK0begin,
900  tims_frame.get()->getOneOverK0Transformation(
901  scan_mobility_start));
902 
903  mass_spectrum.setParameterValue(
904  QualifiedMassSpectrumParameter::OneOverK0end,
905  tims_frame.get()->getOneOverK0Transformation(
906  scan_mobility_end));
907 
908  first = false;
909  }
910 
911 
912  if(want_binary_data)
913  {
914  combiner.combine(combiner_result,
915  tims_frame.get()->cumulateScanToTrace(
916  scan_mobility_start, scan_mobility_end));
917  }
918  else
919  {
920  break;
921  }
922  }
923 
924 
925  if(first == true)
926  {
927  throw ExceptionNotFound(
928  QObject::tr(
929  "ERROR in getQualifiedMassSpectrumByPrecursorId, precursor "
930  "id=%1 not found")
931  .arg(precursor_index));
932  }
933 
934 
935  if(want_binary_data)
936  {
937 
938  pappso::Trace trace(combiner_result);
939  qDebug();
940 
941  if(trace.size() > 0)
942  {
943  if(mcsp_ms1Filter != nullptr)
944  {
945  mcsp_ms1Filter->filter(trace);
946  }
947 
948  qDebug();
949  mass_spectrum.setMassSpectrumSPtr(
950  MassSpectrum(trace).makeMassSpectrumSPtr());
951  mass_spectrum.setEmptyMassSpectrum(false);
952  }
953  else
954  {
955  mass_spectrum.setMassSpectrumSPtr(nullptr);
956  mass_spectrum.setEmptyMassSpectrum(true);
957  }
958  }
959  }
960  }
961 
962  catch(PappsoException &error)
963  {
964  throw error;
965  }
966  catch(std::exception &error)
967  {
968  qDebug() << QString("Failure %1 ").arg(error.what());
969  }
970  return mass_spectrum;
971 }
972 
973 
974 void
976  QualifiedMassSpectrum &mass_spectrum,
977  std::size_t ms2_index,
978  std::size_t precursor_index,
979  bool want_binary_data)
980 {
981  qDebug();
982  try
983  {
984  QSqlDatabase qdb = openDatabaseConnection();
985  MassSpectrumId spectrum_id;
986 
987  spectrum_id.setSpectrumIndex(precursor_index);
988  spectrum_id.setNativeId(
989  QString("precursor=%1 idxms2=%2").arg(precursor_index).arg(ms2_index));
990 
991  mass_spectrum.setMassSpectrumId(spectrum_id);
992 
993  mass_spectrum.setMsLevel(2);
994  mass_spectrum.setPrecursorSpectrumIndex(ms2_index - 1);
995 
996  mass_spectrum.setEmptyMassSpectrum(true);
997 
998  qdb = openDatabaseConnection();
999  // m_mutex.lock();
1000  // if(m_query != nullptr)
1001  // {
1002  // *m_query =
1003  // qdb.exec(QString("SELECT PasefFrameMsMsInfo.*, Precursors.*
1004  // FROM "
1005  // "PasefFrameMsMsInfo INNER JOIN Precursors ON "
1006  // "PasefFrameMsMsInfo.Precursor=Precursors.Id
1007  // where " "Precursors.Id=%1;")
1008  // .arg(precursor_index));
1009  // }
1010  QSqlQuery q =
1011  qdb.exec(QString("SELECT PasefFrameMsMsInfo.*, Precursors.* FROM "
1012  "PasefFrameMsMsInfo INNER JOIN Precursors ON "
1013  "PasefFrameMsMsInfo.Precursor=Precursors.Id where "
1014  "Precursors.Id=%1;")
1015  .arg(precursor_index));
1016  if(q.lastError().isValid())
1017  {
1018  qDebug();
1019  throw PappsoException(
1020  QObject::tr("ERROR in TIMS sqlite database file %1, executing SQL "
1021  "command %2:\n%3\n%4\n%5")
1022  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
1023  .arg(q.lastQuery())
1024  .arg(qdb.lastError().databaseText())
1025  .arg(qdb.lastError().driverText())
1026  .arg(qdb.lastError().nativeErrorCode()));
1027  }
1028  qDebug();
1029  // m_mutex.unlock();
1030  if(q.size() == 0)
1031  {
1032 
1033  throw ExceptionNotFound(
1034  QObject::tr(
1035  "ERROR in getQualifiedMassSpectrumByPrecursorId, precursor "
1036  "id=%1 not found")
1037  .arg(precursor_index));
1038  }
1039  else
1040  {
1041  // qDebug() << " q.size()="<< q.size();
1042  qDebug();
1043  bool first = true;
1044  std::size_t scan_mobility_start = 0;
1045  std::size_t scan_mobility_end = 0;
1046  std::vector<std::size_t> tims_frame_list;
1047 
1048  while(q.next())
1049  {
1050  tims_frame_list.push_back(q.value(0).toLongLong());
1051  if(first)
1052  {
1053  // mass_spectrum.setPrecursorCharge(q.value(11).toInt());
1054  // mass_spectrum.setPrecursorMz(q.value(10).toDouble());
1055  // mass_spectrum.setPrecursorIntensity(q.value(13).toDouble());
1056 
1057  mass_spectrum.appendPrecursorIonData(
1058  PrecursorIonData(q.value(10).toDouble(),
1059  q.value(11).toInt(),
1060  q.value(13).toDouble()));
1061 
1062  mass_spectrum.setPrecursorNativeId(
1063  QString("frame=%1 begin=%2 end=%3 precursor=%4 idxms2=%5")
1064  .arg(q.value(14).toLongLong())
1065  .arg(q.value(1).toLongLong())
1066  .arg(q.value(2).toLongLong())
1067  .arg(precursor_index)
1068  .arg(ms2_index - 1));
1069  // mass_spectrum.setPrecursorSpectrumIndex();
1070 
1071  scan_mobility_start = q.value(1).toLongLong();
1072  scan_mobility_end = q.value(2).toLongLong();
1073 
1074  mass_spectrum.setParameterValue(
1075  QualifiedMassSpectrumParameter::IsolationMz,
1076  q.value(3).toDouble());
1077  mass_spectrum.setParameterValue(
1078  QualifiedMassSpectrumParameter::IsolationWidth,
1079  q.value(4).toDouble());
1080 
1081  mass_spectrum.setParameterValue(
1082  QualifiedMassSpectrumParameter::CollisionEnergy,
1083  q.value(5).toFloat());
1084  mass_spectrum.setParameterValue(
1085  QualifiedMassSpectrumParameter::BrukerPrecursorIndex,
1086  q.value(6).toInt());
1087 
1088  first = false;
1089  }
1090  }
1091  // QMutexLocker locker(&m_mutex_spectrum);
1092  qDebug();
1093  pappso::TimsFrameCstSPtr tims_frame, previous_frame;
1094  // TracePlusCombiner combiner;
1095  // MapTrace combiner_result;
1096  std::map<quint32, quint32> raw_spectrum;
1097  first = true;
1098  for(std::size_t tims_id : tims_frame_list)
1099  {
1100 
1101  tims_frame = getTimsFrameCstSPtrCached(tims_id);
1102  if(first)
1103  {
1104  mass_spectrum.setRtInSeconds(tims_frame.get()->getTime());
1105 
1106  mass_spectrum.setParameterValue(
1107  QualifiedMassSpectrumParameter::OneOverK0begin,
1108  tims_frame.get()->getOneOverK0Transformation(
1109  scan_mobility_start));
1110 
1111  mass_spectrum.setParameterValue(
1112  QualifiedMassSpectrumParameter::OneOverK0end,
1113  tims_frame.get()->getOneOverK0Transformation(
1114  scan_mobility_end));
1115 
1116  first = false;
1117  }
1118 
1119 
1120  if(want_binary_data)
1121  {
1122  qDebug();
1123  /*combiner.combine(combiner_result,
1124  tims_frame.get()->cumulateScanToTrace(
1125  scan_mobility_start, scan_mobility_end));*/
1126  if(previous_frame.get() != nullptr)
1127  {
1128  if(previous_frame.get()->hasSameCalibrationData(
1129  *tims_frame.get()))
1130  {
1131  }
1132  else
1133  {
1134  throw ExceptionNotFound(
1135  QObject::tr(
1136  "ERROR in %1 %2, different calibration data "
1137  "between frame id %3 and frame id %4")
1138  .arg(__FILE__)
1139  .arg(__FUNCTION__)
1140  .arg(previous_frame.get()->getId())
1141  .arg(tims_frame.get()->getId()));
1142  }
1143  }
1144  tims_frame.get()->cumulateScansInRawMap(
1145  raw_spectrum, scan_mobility_start, scan_mobility_end);
1146  qDebug();
1147  }
1148  previous_frame = tims_frame;
1149  }
1150  qDebug() << " precursor_index=" << precursor_index
1151  << " num_rows=" << tims_frame_list.size()
1152  << " sql=" << q.lastQuery() << " "
1153  << (std::size_t)QThread::currentThreadId();
1154  if(first == true)
1155  {
1156  throw ExceptionNotFound(
1157  QObject::tr(
1158  "ERROR in getQualifiedMassSpectrumByPrecursorId, precursor "
1159  "id=%1 not found")
1160  .arg(precursor_index));
1161  }
1162  if(want_binary_data)
1163  {
1164  qDebug();
1165  // peak_pick.filter(trace);
1166  pappso::Trace trace;
1168  {
1169  trace =
1170  tims_frame.get()->getTraceFromCumulatedScansBuiltinCentroid(
1171  raw_spectrum);
1172  }
1173  else
1174  {
1175  // no builtin centroid:
1176 
1177  trace =
1178  tims_frame.get()->getTraceFromCumulatedScans(raw_spectrum);
1179  }
1180 
1181  if(trace.size() > 0)
1182  {
1183  qDebug() << trace.size() << " "
1184  << (std::size_t)QThread::currentThreadId();
1185 
1186  if(mcsp_ms2Filter != nullptr)
1187  {
1188  // FilterTriangle filter;
1189  // filter.setTriangleSlope(50, 0.02);
1190  // filter.filter(trace);
1191  // trace.filter(pappso::FilterHighPass(10));
1192  mcsp_ms2Filter->filter(trace);
1193  }
1194 
1195  // FilterScaleFactorY filter_scale((double)1 /
1196  // (double)tims_frame_list.size());
1197  // filter_scale.filter(trace);
1198  qDebug();
1199  mass_spectrum.setMassSpectrumSPtr(
1200  MassSpectrum(trace).makeMassSpectrumSPtr());
1201  mass_spectrum.setEmptyMassSpectrum(false);
1202  }
1203  else
1204  {
1205  mass_spectrum.setMassSpectrumSPtr(nullptr);
1206  mass_spectrum.setEmptyMassSpectrum(true);
1207  }
1208 
1209  qDebug();
1210  }
1211  qDebug();
1212  }
1213  }
1214 
1215  catch(PappsoException &error)
1216  {
1217  throw error;
1218  }
1219  catch(std::exception &error)
1220  {
1221  qDebug() << QString("Failure %1 ").arg(error.what());
1222  }
1223  qDebug();
1224 }
1225 
1226 
1229 {
1230  QMutexLocker locker(&m_mutex);
1231  for(auto &tims_frame : m_timsFrameBaseCache)
1232  {
1233  if(tims_frame.get()->getId() == timsId)
1234  {
1235  m_timsFrameBaseCache.push_back(tims_frame);
1236  return tims_frame;
1237  }
1238  }
1239 
1240  m_timsFrameBaseCache.push_back(getTimsFrameBaseCstSPtr(timsId));
1241  if(m_timsFrameBaseCache.size() > m_cacheSize)
1242  m_timsFrameBaseCache.pop_front();
1243  return m_timsFrameBaseCache.back();
1244 }
1245 
1248 {
1249  QMutexLocker locker(&m_mutex);
1250  for(auto &tims_frame : m_timsFrameCache)
1251  {
1252  if(tims_frame.get()->getId() == timsId)
1253  {
1254  m_timsFrameCache.push_back(tims_frame);
1255  return tims_frame;
1256  }
1257  }
1258 
1259  m_timsFrameCache.push_back(getTimsFrameCstSPtr(timsId));
1260  if(m_timsFrameCache.size() > m_cacheSize)
1261  m_timsFrameCache.pop_front();
1262  return m_timsFrameCache.back();
1263 }
1264 
1265 void
1267 {
1268  mcsp_ms2Filter = filter;
1269 }
1270 void
1272 {
1273  mcsp_ms1Filter = filter;
1274 }
1275 
1276 std::vector<TimsXicStructure>
1278  const std::vector<std::size_t> &precursor_id_list,
1279  PrecisionPtr precision_ptr,
1280  XicExtractMethod xicExtractMethod,
1281  double rtRange) const
1282 {
1283 
1284  qDebug();
1285  std::vector<TimsXicStructure> xic_list;
1286 
1287  try
1288  {
1289  QSqlDatabase qdb = openDatabaseConnection();
1290 
1291  for(auto precursor_id : precursor_id_list)
1292  {
1293  QSqlQuery q = qdb.exec(
1294  QString("SELECT Frames.Time, "
1295  "PasefFrameMsMsInfo.Frame,PasefFrameMsMsInfo.ScanNumBegin,"
1296  "PasefFrameMsMsInfo.ScanNumEnd, Precursors.MonoisotopicMz, "
1297  "Precursors.Charge FROM "
1298  "PasefFrameMsMsInfo INNER JOIN Precursors ON "
1299  "PasefFrameMsMsInfo.Precursor=Precursors.Id INNER JOIN "
1300  "Frames ON PasefFrameMsMsInfo.Frame=Frames.Id where "
1301  "Precursors.Id=%1;")
1302  .arg(precursor_id));
1303  if(q.lastError().isValid())
1304  {
1305  qDebug();
1306  throw PappsoException(
1307  QObject::tr(
1308  "ERROR in TIMS sqlite database file %1, executing SQL "
1309  "command %2:\n%3\n%4\n%5")
1310  .arg(m_timsDataDirectory.absoluteFilePath("analysis.tdf"))
1311  .arg(q.lastQuery())
1312  .arg(qdb.lastError().databaseText())
1313  .arg(qdb.lastError().driverText())
1314  .arg(qdb.lastError().nativeErrorCode()));
1315  }
1316 
1317  while(q.next())
1318  {
1319  // Frame, ScanNumBegin, ScanNumEnd, IsolationMz, ColliqionEnergy,
1320  // Precursor
1321  // Id, LargestPeakMz, AverageMz, MonoisotopicMz, Charge,
1322  // ScanNumber, Intensity, Parent
1323  TimsXicStructure xic_structure;
1324 
1325  xic_structure.precursorId = precursor_id;
1326  xic_structure.mzRange =
1327  MzRange(q.value(4).toDouble(), precision_ptr);
1328  xic_structure.scanNumBegin = q.value(2).toUInt();
1329  xic_structure.scanNumEnd = q.value(3).toUInt();
1330  xic_structure.rtTarget = q.value(0).toDouble();
1331  // xic_structure.charge = q.value(5).toUInt();
1332 
1333  xic_list.push_back(xic_structure);
1334  }
1335  }
1336  qDebug();
1337 
1338  TimsXicExtractorInterface *extractor_p = new TimsDirectXicExtractor(this);
1339  extractor_p->setXicExtractMethod(xicExtractMethod);
1340  extractor_p->extractTimsXicList(xic_list, rtRange);
1341  }
1342  catch(PappsoException &error)
1343  {
1344  throw error;
1345  }
1346  catch(std::exception &error)
1347  {
1348  qDebug() << QString("Failure %1 ").arg(error.what());
1349  }
1350 
1351  qDebug();
1352  return xic_list;
1353 }
pappso::TimsData::m_mapMzCalibrationRecord
std::map< int, QSqlRecord > m_mapMzCalibrationRecord
Definition: timsdata.h:231
pappso::TimsData::mcsp_ms2Filter
pappso::FilterInterfaceCstSPtr mcsp_ms2Filter
Definition: timsdata.h:223
pappso::TimsData::m_totalNumberOfPrecursors
std::size_t m_totalNumberOfPrecursors
Definition: timsdata.h:218
pappso::TimsData::getMs2BuiltinCentroid
bool getMs2BuiltinCentroid() const
tells if simple centroid filter on raw tims data for MS2 is enabled or not
Definition: timsdata.cpp:219
pappso::MassSpectrumCstSPtr
std::shared_ptr< const MassSpectrum > MassSpectrumCstSPtr
Definition: massspectrum.h:55
pappso::TimsData::setMs2FilterCstSPtr
void setMs2FilterCstSPtr(pappso::FilterInterfaceCstSPtr &filter)
filter interface to apply just after raw MS2 specturm extraction the filter can be a list of filters ...
Definition: timsdata.cpp:1266
pappso::TimsXicStructure::precursorId
std::size_t precursorId
Definition: timsdata.h:51
pappso::TimsData::getMassSpectrumCstSPtrByRawIndex
pappso::MassSpectrumCstSPtr getMassSpectrumCstSPtrByRawIndex(std::size_t raw_index)
get a mass spectrum given its spectrum index
Definition: timsdata.cpp:319
pappso::TimsData::getQualifiedMs1MassSpectrumByPrecursorId
QualifiedMassSpectrum getQualifiedMs1MassSpectrumByPrecursorId(std::size_t ms2_index, std::size_t precursor_index, bool want_binary_data)
Definition: timsdata.cpp:810
pappso::TimsData::mcsp_ms1Filter
pappso::FilterInterfaceCstSPtr mcsp_ms1Filter
Definition: timsdata.h:224
pappso::TimsData::m_timsFrameBaseCache
std::deque< TimsFrameBaseCstSPtr > m_timsFrameBaseCache
Definition: timsdata.h:221
timsdirectxicextractor.h
minimum functions to extract XICs from Tims Data
pappso::TimsData::getTimsFrameBaseCstSPtrCached
TimsFrameBaseCstSPtr getTimsFrameBaseCstSPtrCached(std::size_t timsId)
Definition: timsdata.cpp:1228
pappso::TimsFrameSPtr
std::shared_ptr< TimsFrame > TimsFrameSPtr
Definition: timsframe.h:40
pappso::TimsData::getTimsMS1FrameIdRange
std::vector< std::size_t > getTimsMS1FrameIdRange(double rt_begin, double rt_end) const
Definition: timsdata.cpp:412
pappso::TracePlusCombiner::combine
virtual MapTrace & combine(MapTrace &map_trace, const Trace &trace) const override
Definition: tracepluscombiner.cpp:52
pappso::MzCalibrationStore
Definition: mzcalibrationstore.h:40
pappso::TimsFrameBase
Definition: timsframebase.h:48
pappso::TimsBinDec
Definition: timsbindec.h:41
pappso::TimsXicExtractorInterface
Definition: timsxicextractorinterface.h:42
pappso::TimsBinDec::getTimsFrameSPtrByOffset
TimsFrameSPtr getTimsFrameSPtrByOffset(std::size_t timsId, std::size_t timsOffset) const
Definition: timsbindec.cpp:143
pappso
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition: aa.cpp:39
pappso::MassSpectrum
Class to represent a mass spectrum.
Definition: massspectrum.h:71
pappso::TimsData::setMs2BuiltinCentroid
void setMs2BuiltinCentroid(bool centroid)
enable or disable simple centroid filter on raw tims data for MS2
Definition: timsdata.cpp:213
pappso::FilterInterfaceCstSPtr
std::shared_ptr< const FilterInterface > FilterInterfaceCstSPtr
Definition: filterinterface.h:47
pappso::TimsData::m_cacheSize
std::size_t m_cacheSize
Definition: timsdata.h:219
timsdata.h
main Tims data handler
pappso::TimsData::TimsData
TimsData(QDir timsDataDirectory)
build using the tims data directory
Definition: timsdata.cpp:46
pappso::TimsData::getMatchPrecursorIdByKo
std::vector< std::size_t > getMatchPrecursorIdByKo(std::vector< std::vector< double >> ids, double ko_value)
Definition: timsdata.cpp:632
pappso::TimsData::setMs1FilterCstSPtr
void setMs1FilterCstSPtr(pappso::FilterInterfaceCstSPtr &filter)
filter interface to apply just after raw MS1 specturm extraction the filter can be a list of filters ...
Definition: timsdata.cpp:1271
pappso::TimsFrameBaseCstSPtr
std::shared_ptr< const TimsFrameBase > TimsFrameBaseCstSPtr
Definition: timsframebase.h:41
pappso::TimsData::extractXicListByPrecursorIds
std::vector< TimsXicStructure > extractXicListByPrecursorIds(const std::vector< std::size_t > &precursor_id_list, PrecisionPtr precision_ptr, XicExtractMethod xicExtractMethod, double rtRange) const
extract a list of XICs from Tims data
Definition: timsdata.cpp:1277
pappso::QualifiedMassSpectrum::setParameterValue
void setParameterValue(QualifiedMassSpectrumParameter parameter, const QVariant &value)
Definition: qualifiedmassspectrum.cpp:461
pappso::MapTrace
Definition: maptrace.h:33
pappso::TimsXicStructure::scanNumBegin
std::size_t scanNumBegin
Definition: timsdata.h:54
pappso::TimsData::getMsLevelBySpectrumIndex
unsigned int getMsLevelBySpectrumIndex(std::size_t spectrum_index)
Definition: timsdata.cpp:682
pappso::QualifiedMassSpectrum::setMassSpectrumSPtr
void setMassSpectrumSPtr(MassSpectrumSPtr massSpectrum)
Set the MassSpectrumSPtr.
Definition: qualifiedmassspectrum.cpp:125
pappso::TimsData
Definition: timsdata.h:71
pappso::TimsData::getTimsFrameBaseCstSPtr
TimsFrameBaseCstSPtr getTimsFrameBaseCstSPtr(std::size_t timsId) const
get a Tims frame base (no binary data file access) with his database ID
Definition: timsdata.cpp:328
pappso::TimsDirectXicExtractor
Definition: timsdirectxicextractor.h:38
pappso::TimsData::getClosestPrecursorIdByMz
std::vector< std::size_t > getClosestPrecursorIdByMz(std::vector< std::vector< double >> ids, double mz_value)
Definition: timsdata.cpp:658
pappso::QualifiedMassSpectrum::setMsLevel
void setMsLevel(uint ms_level)
Set the mass spectrum level.
Definition: qualifiedmassspectrum.cpp:179
pappso::TimsData::getTimsFrameCstSPtrCached
TimsFrameCstSPtr getTimsFrameCstSPtrCached(std::size_t timsId)
get a Tims frame with his database ID but look in the cache first
Definition: timsdata.cpp:1247
pappso::QualifiedMassSpectrum::size
std::size_t size() const
Definition: qualifiedmassspectrum.cpp:492
pappso::QualifiedMassSpectrum::setRtInSeconds
void setRtInSeconds(pappso_double rt)
Set the retention time in seconds.
Definition: qualifiedmassspectrum.cpp:195
pappso::TimsData::m_mutex
QMutex m_mutex
Definition: timsdata.h:235
pappso::MzRange
Definition: mzrange.h:46
pappso::Trace
A simple container of DataPoint instances.
Definition: trace.h:132
pappso::XicExtractMethod
XicExtractMethod
Definition: types.h:200
pappso::QualifiedMassSpectrum
Class representing a fully specified mass spectrum.
Definition: qualifiedmassspectrum.h:85
pappso::TimsData::getScanCoordinateFromRawIndex
std::pair< std::size_t, std::size_t > getScanCoordinateFromRawIndex(std::size_t spectrum_index) const
Definition: timsdata.cpp:225
pappso::TimsData::m_timsDataDirectory
QDir m_timsDataDirectory
Definition: timsdata.h:214
pappso::TimsData::getMassSpectrumCstSPtr
pappso::MassSpectrumCstSPtr getMassSpectrumCstSPtr(std::size_t timsId, std::size_t scanNum)
get a mass spectrum given the tims frame database id and scan number within tims frame
Definition: timsdata.cpp:532
pappso::TimsData::getQualifiedMassSpectrumByRawIndex
QualifiedMassSpectrum getQualifiedMassSpectrumByRawIndex(std::size_t spectrum_index, bool want_binary_data)
Definition: timsdata.cpp:691
pappso::QualifiedMassSpectrum::setPrecursorNativeId
void setPrecursorNativeId(const QString &native_id)
Set the scan native id of the precursor ion.
Definition: qualifiedmassspectrum.cpp:417
pappso::TimsData::~TimsData
~TimsData()
Definition: timsdata.cpp:203
pappso::QualifiedMassSpectrum::appendPrecursorIonData
void appendPrecursorIonData(const PrecursorIonData &precursor_ion_data)
Definition: qualifiedmassspectrum.cpp:430
pappso::QualifiedMassSpectrum::setMassSpectrumId
void setMassSpectrumId(const MassSpectrumId &iD)
Set the MassSpectrumId.
Definition: qualifiedmassspectrum.cpp:149
pappso::MzCalibrationStore::getInstance
MzCalibrationInterfaceSPtr getInstance(double T1_frame, double T2_frame, const QSqlRecord &mzcalibration_record)
Definition: mzcalibrationstore.cpp:46
pappso::TimsFrameBaseSPtr
std::shared_ptr< TimsFrameBase > TimsFrameBaseSPtr
Definition: timsframebase.h:39
pappso::TimsData::getTotalNumberOfPrecursors
std::size_t getTotalNumberOfPrecursors() const
get the number of precursors analyzes by PASEF
Definition: timsdata.cpp:547
pappso::TimsData::m_totalNumberOfScans
std::size_t m_totalNumberOfScans
Definition: timsdata.h:217
pappso::TimsData::mpa_timsBinDec
TimsBinDec * mpa_timsBinDec
Definition: timsdata.h:215
pappso::TimsXicExtractorInterface::setXicExtractMethod
void setXicExtractMethod(XicExtractMethod method)
set the XIC extraction method
Definition: timsxicextractorinterface.cpp:43
pappso::TimsData::m_timsFrameCache
std::deque< TimsFrameCstSPtr > m_timsFrameCache
Definition: timsdata.h:220
pappso::ExceptionNotFound
Definition: exceptionnotfound.h:32
pappso::TimsXicStructure
structure needed to extract XIC from Tims data
Definition: timsdata.h:49
pappso::PrecisionBase
Definition: precision.h:44
pappso::TimsData::getTotalNumberOfScans
std::size_t getTotalNumberOfScans() const
get the total number of scans
Definition: timsdata.cpp:540
pappso::TimsData::getPrecursorsFromMzRtCharge
std::vector< std::size_t > getPrecursorsFromMzRtCharge(int charge, double mz_val, double rt_sec, double k0)
guess possible precursor ids given a charge, m/z, retention time and k0
Definition: timsdata.cpp:553
pappso::MassSpectrumId
Definition: massspectrumid.h:38
pappso::QualifiedMassSpectrum::setEmptyMassSpectrum
void setEmptyMassSpectrum(bool is_empty_mass_spectrum)
Definition: qualifiedmassspectrum.cpp:164
pappso::TimsXicStructure::mzRange
MzRange mzRange
Definition: timsdata.h:53
pappso::QualifiedMassSpectrum::setPrecursorSpectrumIndex
void setPrecursorSpectrumIndex(std::size_t precursor_scan_num)
Set the scan number of the precursor ion.
Definition: qualifiedmassspectrum.cpp:400
pappso::TimsData::getQualifiedMs2MassSpectrumByPrecursorId
void getQualifiedMs2MassSpectrumByPrecursorId(QualifiedMassSpectrum &mass_spectrum, std::size_t ms2_index, std::size_t precursor_index, bool want_binary_data)
Definition: timsdata.cpp:975
pappso::TimsData::getTimsFrameCstSPtr
TimsFrameCstSPtr getTimsFrameCstSPtr(std::size_t timsId) const
get a Tims frame with his database ID
Definition: timsdata.cpp:446
pappso::TimsXicStructure::scanNumEnd
std::size_t scanNumEnd
Definition: timsdata.h:55
pappso::TimsData::mpa_mzCalibrationStore
MzCalibrationStore * mpa_mzCalibrationStore
Definition: timsdata.h:233
pappso::MassSpectrumId::setSpectrumIndex
void setSpectrumIndex(std::size_t index)
Definition: massspectrumid.cpp:103
pappso::QualifiedMassSpectrum::setDtInMilliSeconds
void setDtInMilliSeconds(pappso_double rt)
Set the drift time in milliseconds.
Definition: qualifiedmassspectrum.cpp:219
pappso::MassSpectrumId::setNativeId
void setNativeId(const QString &native_id)
Definition: massspectrumid.cpp:89
pappso::TimsData::getRawIndexFromCoordinate
std::size_t getRawIndexFromCoordinate(std::size_t frame_id, std::size_t scan_num) const
Definition: timsdata.cpp:270
pappso::TimsXicExtractorInterface::extractTimsXicList
virtual void extractTimsXicList(std::vector< TimsXicStructure > &timsXicList, double rtRange) const =0
extract XICs for given coordinates XICs are extracted given their coordinates : retention time target...
pappso::TimsFrameCstSPtr
std::shared_ptr< const TimsFrame > TimsFrameCstSPtr
Definition: timsframe.h:42
pappso::TimsData::openDatabaseConnection
QSqlDatabase openDatabaseConnection() const
Definition: timsdata.cpp:168
pappso::TimsXicStructure::rtTarget
pappso::pappso_double rtTarget
Definition: timsdata.h:56
pappso::PrecursorIonData
Definition: qualifiedmassspectrum.h:62
pappso::TracePlusCombiner
Definition: tracepluscombiner.h:27
pappso::TimsData::m_builtinMs2Centroid
bool m_builtinMs2Centroid
enable builtin centroid on raw tims integers by default
Definition: timsdata.h:228
pappso::PappsoException
Definition: pappsoexception.h:42
pappso::FilterTriangle::setTriangleSlope
double setTriangleSlope(double intensity, double mz)
Definition: filtertriangle.cpp:47