libpappsomspp
Library for mass spectrometry
Loading...
Searching...
No Matches
jsoninput.cpp
Go to the documentation of this file.
1
2/**
3 * \file pappsomspp/masschroq/input/jsoninput.cpp
4 * \date 02/01/2025
5 * \author Olivier Langella
6 * \brief process json document input
7 */
8
9/*******************************************************************************
10 * Copyright (c) 2025 Olivier Langella
11 *<Olivier.Langella@universite-paris-saclay.fr>.
12 *
13 * This file is part of MassChroQ.
14 *
15 * MassChroQ is free software: you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation, either version 3 of the License, or
18 * (at your option) any later version.
19 *
20 * MassChroQ is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with MassChroQ. If not, see <http://www.gnu.org/licenses/>.
27 *
28 ******************************************************************************/
29
30
31#include "pappsomspp/core/masschroq/input/jsoninput.h"
32#include "pappsomspp/core/masschroq/utils.h"
33#include "pappsomspp/core/exception/exceptionnotfound.h"
34#include "pappsomspp/core/exception/exceptionnotrecognized.h"
35#include "pappsomspp/core/peptide/peptideproformaparser.h"
36#include "pappsomspp/core/msfile/msfileaccessor.h"
37#include "pappsomspp/core/processing/filters/filtersuitestring.h"
38#include "pappsomspp/core/processing/detection/tracedetectionzivy.h"
39#include <QtConcurrent>
40#include <QStringList>
41
42pappso::masschroq::JsonInput::JsonInput(pappso::UiMonitorInterface &ui_monitor,
43 const QString &tmp_dir_name,
44 const QJsonDocument &json_doc)
45 : m_jsonDocument(json_doc), m_tmpDirName(tmp_dir_name), m_uiMonitor(ui_monitor)
46{
47}
48
52
53void
54pappso::masschroq::JsonInput::action(CborOutputStream &cbor_output)
55{
56 readAlignmentMethodSp();
57 readQuantificationMethodSp();
58 read_protein_list();
59 read_peptide_list();
60 cbor_output.writeActionBegin("quantification");
61
62
63 readProjectParameters();
64
65 // QJsonDocument doc;
66 // doc.setObject(params);
67 // qDebug() << doc.toJson();
68 m_isMatchBetweenRun = msp_quantificationMethod.get()->getMatchBetweenRun();
69
70 pappso::ProjectParam param({pappso::ProjectParamCategory::quantification, "", QVariant()});
71
72
73 param.name = "mcq_version";
74 param.value = pappso::masschroq::Utils::getVersion();
75 m_projectParameters.setProjectParam(param);
76
77 m_projectParameters.merge(msp_alignmentMethod.get()->getProjectParameters());
78 m_projectParameters.merge(msp_quantificationMethod.get()->getProjectParameters());
79
80 cbor_output.writeProjectParameters(m_projectParameters);
81
82 qDebug();
83
84 QJsonObject methods = m_jsonDocument.object().value("masschroq_methods").toObject();
85 cbor_output.writeJsonObject("masschroq_methods", methods);
86
87 cbor_output.getCborStreamWriter().append("identification_data");
88 cbor_output.getCborStreamWriter().startMap();
89 QJsonObject msrun_list = documentFind("identification_data", "msrun_list").toObject();
90 cbor_output.writeJsonObject("msrun_list", msrun_list);
91 QJsonObject protein_list = documentFind("identification_data", "protein_list").toObject();
92 cbor_output.writeJsonObject("protein_list", protein_list);
93 QJsonObject peptide_list = documentFind("identification_data", "peptide_list").toObject();
94 cbor_output.writeJsonObject("peptide_list", peptide_list);
95 QJsonObject msrunpeptide_list =
96 documentFind("identification_data", "msrunpeptide_list").toObject();
97 cbor_output.writeJsonObject("msrunpeptide_list", msrunpeptide_list);
98 cbor_output.getCborStreamWriter().endMap();
99
100 qDebug();
101 readMzDataFiles();
102 read_msrun_peptide_observations();
103
104 QJsonObject actions = m_jsonDocument.object().value("actions").toObject();
105 cbor_output.writeJsonObject("actions", actions);
106
107 readAction(cbor_output);
108}
109
110const QJsonValue
111pappso::masschroq::JsonInput::documentFind(const QString &key1, const QString &key2) const
112{
113 QJsonObject obj1 = m_jsonDocument.object();
114 auto it1 = obj1.find(key1);
115 if(it1 != obj1.end())
116 {
117 QJsonObject obj2 = it1.value().toObject();
118 auto it2 = obj2.find(key2);
119 if(it2 != obj2.end())
120 {
121 return it2.value();
122 }
123 else
124 {
125 throw pappso::ExceptionNotFound(
126 QObject::tr("key2 %1 not found in json document element %2").arg(key2).arg(key1));
127 }
128 }
129 else
130 {
131 throw pappso::ExceptionNotFound(QObject::tr("key1 %1 not found in json document").arg(key1));
132 }
133}
134
135
136void
137pappso::masschroq::JsonInput::readMzDataFiles()
138{
139 qDebug();
140 std::map<QString, QString> msfilepathlist;
141 const QJsonObject msrun_list(documentFind("identification_data", "msrun_list").toObject());
142 auto it = msrun_list.begin();
143 while(it != msrun_list.end())
144 {
145 qDebug() << it.key();
146 qDebug() << it.value().toObject().value("file");
147 //<data_file id="samp0" format="mzxml" path="bsa1.mzXML"
148 // type="profile" />
149 msfilepathlist.insert({it.key(), it.value().toObject().value("file").toString()});
150 it++;
151 }
152
153
154 qDebug();
155 std::function<pappso::masschroq::MsRunPeptideListSp(const std::pair<QString, QString> &)>
156 mapFilenameList = [](const std::pair<QString, QString> &mapit) {
157 pappso::MsFileAccessor file_access(mapit.second, mapit.first);
158 file_access.setPreferredFileReaderType(Enums::MsDataFormat::brukerTims,
159 Enums::FileReaderType::tims_ms2);
160
161 std::vector<pappso::MsRunIdCstSPtr> msrunid_list = file_access.getMsRunIds();
162
163
164 if(file_access.getFileFormat() == Enums::MsDataFormat::unknown)
165 {
166 throw pappso::ExceptionNotRecognized("MS data file format not recognized");
167 }
168 if(msrunid_list.size() == 0)
169 {
170 throw pappso::PappsoException("msrunid_list.size() == 0");
171 }
172
173
174 pappso::MsRunReaderSPtr run_reader = file_access.getMsRunReaderSPtrByRunId("", mapit.first);
175 run_reader.get()->setMonoThread(true);
176 pappso::masschroq::MsRunSp msrun = std::make_shared<pappso::masschroq::MsRun>(run_reader);
177 run_reader.get()->releaseDevice();
178 run_reader.get()->setMonoThread(false);
179 return std::make_shared<pappso::masschroq::MsRunPeptideList>(msrun);
180 };
181
182 qDebug();
183
184 m_uiMonitor.appendText(QObject::tr("reading %1 msruns").arg(msfilepathlist.size()));
185
186
187 pappso::UiMonitorInterface *local_monitor = &m_uiMonitor;
188 std::map<QString, pappso::masschroq::MsRunPeptideListSp> *p_localPtrOnmsrunpeptidelist =
189 &m_msfileList;
190
191 std::function<void(std::size_t, const pappso::masschroq::MsRunPeptideListSp)> reduce_function =
192 [local_monitor, p_localPtrOnmsrunpeptidelist](
193 std::size_t result, const pappso::masschroq::MsRunPeptideListSp msrun) {
194 local_monitor->setStatus(QObject::tr("MS run '%1' from file %2: added ")
195 .arg(msrun.get()
196 ->getMsRunSp()
197 .get()
198 ->getMsRunReaderSPtr()
199 .get()
200 ->getMsRunId()
201 .get()
202 ->getXmlId())
203 .arg(msrun.get()
204 ->getMsRunSp()
205 .get()
206 ->getMsRunReaderSPtr()
207 .get()
208 ->getMsRunId()
209 .get()
210 ->getFileName()));
211
212 p_localPtrOnmsrunpeptidelist->insert({msrun.get()
213 ->getMsRunSp()
214 .get()
215 ->getMsRunReaderSPtr()
216 .get()
217 ->getMsRunId()
218 .get()
219 ->getXmlId(),
220 msrun});
221 result++;
222 };
223
224 QFuture<std::size_t> res = QtConcurrent::mappedReduced<std::size_t>(msfilepathlist.begin(),
225 msfilepathlist.end(),
226 mapFilenameList,
227 reduce_function,
228 QtConcurrent::OrderedReduce);
229 res.waitForFinished();
230
231 m_uiMonitor.appendText("reading msruns finished");
232 if(m_msfileList.begin()->second.get()->getMsRunSp().get()->hasTimsTofMobilityIndex())
233 {
234 m_uiMonitor.appendText("ion mobility grid enabled");
235 msp_ionMobilityGrid = std::make_shared<pappso::IonMobilityGrid>();
236 }
237}
238
239void
240pappso::masschroq::JsonInput::readAlignmentMethodSp()
241{
242 msp_alignmentMethod = std::make_shared<pappso::masschroq::AlignmentMethod>("align1");
243
244 msp_alignmentMethod.get()->setJsonObject(
245 documentFind("masschroq_methods", "alignment_method").toObject());
246}
247
248void
249pappso::masschroq::JsonInput::readQuantificationMethodSp()
250{
251 msp_quantificationMethod = std::make_shared<pappso::masschroq::QuantificationMethod>("qm1");
252
253
254 msp_quantificationMethod.get()->setJsonObject(
255 documentFind("masschroq_methods", "quantification_method").toObject());
256
257 /*
258 "quantification_method": {
259 "detection": {
260 "type": "zivy",
261 "meanfilter": 1,
262 "minmax": 3,
263 "maxmin": 2,
264 "threshold_on_max": 5000,
265 "threshold_on_min": 3000,
266 }
267 }
268 */
269}
270
271
272void
273pappso::masschroq::JsonInput::read_protein_list()
274{
275
276
277 const QJsonObject protein_list(documentFind("identification_data", "protein_list").toObject());
278 //<protein desc="conta|P02769|ALBU_BOVIN SERUM ALBUMIN PRECURSOR."
279 // id="P1.1" />
280
281 auto it = protein_list.begin();
282 while(it != protein_list.end())
283 {
284 qDebug() << it.key();
285 qDebug() << it.value().toObject().value("description");
286
287 /// create a new Protein object and set its description
288 pappso::masschroq::ProteinSp p_protein;
289 try
290 {
291 p_protein = std::make_shared<pappso::masschroq::Protein>(
292 it.key(), it.value().toObject().value("description").toString());
293 }
294 catch(pappso::PappsoException &error)
295 {
296 throw pappso::ExceptionNotFound(
297 QObject::tr("problem creating protein :\n%1").arg(it.key()));
298 }
299 /// add this protein to _p_proteins (: map<id, Protein *>)
300 m_proteinMap.insert({p_protein.get()->getId(), p_protein});
301 it++;
302 }
303}
304
305void
306pappso::masschroq::JsonInput::read_peptide_list()
307{
308
309
310 const QJsonObject peptide_list(documentFind("identification_data", "peptide_list").toObject());
311 //<protein desc="conta|P02769|ALBU_BOVIN SERUM ALBUMIN PRECURSOR."
312 // id="P1.1" />
313
314 auto it = peptide_list.begin();
315 while(it != peptide_list.end())
316 {
317 qDebug() << it.key();
318 qDebug() << it.value().toObject().value("proforma");
319
320 /// create a new peptide object and set its description
321 pappso::masschroq::PeptideSp peptide_sp;
322 try
323 {
324
325 std::vector<pappso::masschroq::ProteinSp> protein_list;
326 for(auto prot_id : it.value().toObject().value("proteins").toArray())
327 {
328 auto it = m_proteinMap.find(prot_id.toString());
329 if(it != m_proteinMap.end())
330 {
331 protein_list.push_back(it->second);
332 }
333 else
334 {
335 throw pappso::ExceptionNotFound(
336 QObject::tr("protein id %1 not found").arg(prot_id.toString()));
337 }
338 }
339
340
341 peptide_sp = std::make_shared<pappso::masschroq::Peptide>(
342 it.key(),
343 pappso::PeptideProFormaParser::parseString(
344 it.value().toObject().value("proforma").toString()),
345 protein_list);
346 m_peptideStore.push_back(peptide_sp);
347 peptide_sp.get()->setMods(it.value().toObject().value("mods").toString());
348 m_peptideMap.insert({peptide_sp.get()->getId(), peptide_sp});
349
350 qDebug();
351 QJsonObject json_label_list = it.value().toObject().value("label_list").toObject();
352
353 qDebug();
354 if(!json_label_list.isEmpty())
355 {
356 qDebug();
357 peptide_sp.get()->setJsonLabelList(json_label_list);
358 qDebug();
359 }
360 }
361 catch(pappso::PappsoException &error)
362 {
363 throw pappso::ExceptionNotFound(
364 QObject::tr("problem creating protein :\n%1").arg(it.key()));
365 }
366 it++;
367 }
368
369 qDebug();
370}
371
372void
373pappso::masschroq::JsonInput::read_msrun_peptide_observations()
374{
375 qDebug();
376 const QJsonObject msrunpeptide_list(
377 documentFind("identification_data", "msrunpeptide_list").toObject());
378 auto it = msrunpeptide_list.begin();
379 while(it != msrunpeptide_list.end())
380 {
381 qDebug() << it.key();
382 QJsonObject jmsrun_peptidelist_object = it.value().toObject();
383 auto it_peptide_obs = jmsrun_peptidelist_object.find("peptide_obs");
384 if(it_peptide_obs == jmsrun_peptidelist_object.end())
385 {
386 throw pappso::ExceptionNotFound(
387 QObject::tr("peptide_obs not found in msrunpeptide_list %1").arg(it.key()));
388 }
389 QJsonObject json_msrunobs = it_peptide_obs->toObject();
390 auto it_msrun = m_msfileList.find(it.key());
391 if(it_msrun == m_msfileList.end())
392 {
393 throw pappso::ExceptionNotFound(QObject::tr("msrun %1 not found").arg(it.key()));
394 }
395 pappso::masschroq::MsRunPeptideListSp msrunpep_sp = it_msrun->second;
396
397 auto itpep = json_msrunobs.begin();
398 while(itpep != json_msrunobs.end())
399 {
400 qDebug() << itpep.key();
401 QJsonArray json_obs_list = itpep.value().toArray();
402 auto it_pepmap = m_peptideMap.find(itpep.key());
403 if(it_pepmap == m_peptideMap.end())
404 {
405 throw pappso::ExceptionNotFound(QObject::tr("peptide %1 not found").arg(itpep.key()));
406 }
407 pappso::masschroq::PeptideSp peptide_sp = it_pepmap->second;
408 qDebug() << "json_obs_list.size()=" << json_obs_list.size();
409 for(auto json_obs_value : json_obs_list)
410 {
411 QJsonObject observation = json_obs_value.toObject();
412 qint64 scan = observation.value("scan").toInteger();
413 qint64 index = observation.value("index").toInteger();
414 QString label = observation.value("label").toString();
415 std::uint8_t charge =
416 observation.value("precursor").toObject().value("charge").toInt();
417 try
418 {
419 pappso::masschroq::PeptideLabel *p_label = nullptr;
420 if(!label.isEmpty())
421 {
422 p_label = peptide_sp.get()->getPeptideLabelPtr(label);
423 }
424 if(scan == 0)
425 {
426 msrunpep_sp.get()->addPeptideSpectrumIndexObservation(
427 peptide_sp, p_label, index, charge);
428 }
429 else
430 {
431
432 msrunpep_sp.get()->addPeptideScanNumberObservation(
433 peptide_sp, p_label, scan, charge);
434 }
435
436 peptide_sp.get()->addObservedChargeState(charge);
437 peptide_sp.get()->addObservedInMsRunSp(msrunpep_sp.get()->getMsRunSp());
438 }
439 catch(pappso::PappsoException &err)
440 {
441 throw pappso::PappsoException(
442 QObject::tr("error reading peptide %1 observation scan %2 "
443 "index %3 : %4")
444 .arg(itpep.key())
445 .arg(scan)
446 .arg(index)
447 .arg(err.qwhat()));
448 }
449 }
450
451
452 if(msp_ionMobilityGrid.get() != nullptr)
453 {
454 if(peptide_sp.get() != nullptr)
455 {
456 peptide_sp.get()->populateIonMobilityGrid(msp_ionMobilityGrid.get());
457 }
458 }
459
460
461 itpep++;
462 }
463
464 it++;
465 }
466 qDebug();
467}
468
469void
470pappso::masschroq::JsonInput::computeIsotopologues(double ni_min_abundance)
471{
472 if(ni_min_abundance > 0)
473 { /*
474 for(auto &peptide_sp : m_peptideStore)
475 {
476 peptide_sp.get()->computeIsotopologues(ni_min_abundance);
477 }*/
478 std::function<void(const pappso::masschroq::PeptideSp &)> mapComputeIsotopologues =
479 [ni_min_abundance](const pappso::masschroq::PeptideSp &peptide_sp) {
480 peptide_sp.get()->computeIsotopologues(ni_min_abundance);
481 };
482
483
484 QFuture<void> res = QtConcurrent::map<std::vector<pappso::masschroq::PeptideSp>::iterator>(
485 m_peptideStore.begin(), m_peptideStore.end(), mapComputeIsotopologues);
486 m_uiMonitor.appendText(QObject::tr("Computing isotopologues %1").arg(ni_min_abundance));
487 res.waitForFinished();
488
489 m_uiMonitor.appendText("Computing isotopologues OK");
490 }
491}
492
493
494void
495pappso::masschroq::JsonInput::readAction(CborOutputStream &cbor_output)
496{
497 const QJsonObject group_list(documentFind("actions", "group_list").toObject());
498
499 auto it_group = group_list.begin();
500 while(it_group != group_list.end())
501 {
502 QString id = it_group.key();
503 QJsonArray json_msrun_list = it_group.value().toArray();
504 std::vector<pappso::masschroq::MsRunPeptideListSp> msrun_list;
505 for(auto json_msrun : json_msrun_list)
506 {
507
508 auto it_msrun = m_msfileList.find(json_msrun.toString());
509 if(it_msrun == m_msfileList.end())
510 {
511 throw pappso::ExceptionNotFound(
512 QObject::tr("msrun %1 not found").arg(json_msrun.toString()));
513 }
514 msrun_list.push_back(it_msrun->second);
515 }
516
517 m_msRunGroupSpList.insert({id, std::make_shared<MsRunGroup>(id, msrun_list)});
518 it_group++;
519 }
520
521
522 QJsonObject align_list;
523 try
524 {
525 align_list = documentFind("actions", "align_group").toObject();
526 }
527 catch(const pappso::ExceptionNotFound &notfound)
528 {
529 }
530 if(!align_list.isEmpty())
531 {
532 cbor_output.getCborStreamWriter().append("alignment_data");
533 cbor_output.getCborStreamWriter().startArray();
534
535 std::size_t count_q = 1;
536 QStringList group_keys = align_list.keys();
537 for(auto group_id : group_keys)
538 {
539 auto itgroup = m_msRunGroupSpList.find(group_id);
540 if(itgroup == m_msRunGroupSpList.end())
541 {
542 throw pappso::ExceptionNotFound(QObject::tr("group id %1 not found").arg(group_id));
543 }
544 else
545 {
546 QString ref_id =
547 align_list.value(group_id).toObject().value("alignment_reference").toString();
548 if(!ref_id.isEmpty())
549 {
550 itgroup->second.get()->setAlignmentMethodSp(msp_alignmentMethod, ref_id);
551 }
552 itgroup->second.get()->setIonMobilityGridSp(msp_ionMobilityGrid);
553 itgroup->second.get()->align(cbor_output, QString("a%1").arg(count_q), m_uiMonitor);
554 }
555 count_q++;
556 }
557 cbor_output.getCborStreamWriter().endArray();
558 }
559
560 QVariant quantify_all;
561 try
562 {
563 quantify_all = documentFind("actions", "quantify_all").toVariant();
564 }
565 catch(const pappso::ExceptionNotFound &notfound)
566 {
567 }
568 if(!quantify_all.isNull())
569 {
570 if(quantify_all.toBool())
571 {
572 double ni_ratio = msp_quantificationMethod.get()->getIsotopeMinimumRatio();
573 computeIsotopologues(ni_ratio);
574 std::size_t count_q = 1;
575 cbor_output.getCborStreamWriter().append("quantification_data");
576 cbor_output.getCborStreamWriter().startArray();
577 for(auto &pair_group : m_msRunGroupSpList)
578 {
579 pair_group.second.get()->setIonMobilityGridSp(msp_ionMobilityGrid);
580 pair_group.second.get()->quantify(cbor_output,
581 QString("q%1").arg(count_q),
582 m_tmpDirName,
583 m_uiMonitor,
584 msp_quantificationMethod,
585 m_peptideStore);
586 }
587
588 cbor_output.getCborStreamWriter().endArray();
589 count_q++;
590 }
591 }
592}
593
594void
595pappso::masschroq::JsonInput::readProjectParameters()
596{
597
598 QJsonObject params = m_jsonDocument.object().value("project_parameters").toObject();
599
600 pappso::ProjectParameters parameters(params);
601 m_projectParameters.merge(parameters);
602}
pappso::ExceptionNotRecognized
excetion to use when an item type is not recognized
Definition exceptionnotrecognized.h:42
pappso::MsFileAccessor::setPreferredFileReaderType
void setPreferredFileReaderType(Enums::MsDataFormat format, Enums::FileReaderType reader_type)
given an mz format, explicitly set the preferred reader
Definition msfileaccessor.cpp:347
pappso::MsFileAccessor::getFileFormat
Enums::MsDataFormat getFileFormat() const
get the raw format of mz data
Definition msfileaccessor.cpp:75
pappso::MsFileAccessor::getMsRunIds
std::vector< MsRunIdCstSPtr > getMsRunIds()
Definition msfileaccessor.cpp:202
pappso::MsFileAccessor::getMsRunReaderSPtrByRunId
MsRunReaderSPtr getMsRunReaderSPtrByRunId(const QString &run_id, const QString &xml_id)
get an msrun reader by finding the run_id in file
Definition msfileaccessor.cpp:601
pappso::PappsoException::qwhat
virtual const QString & qwhat() const
Definition pappsoexception.h:68
pappso::PeptideProFormaParser::parseString
static PeptideSp parseString(const QString &pepstr)
Definition peptideproformaparser.cpp:227
pappso::UiMonitorInterface::setStatus
virtual void setStatus(const QString &status)=0
current status of the process
pappso::masschroq::CborOutputStream::writeJsonObject
void writeJsonObject(const QString &name, const QJsonObject &json_object)
Definition cboroutputstream.cpp:93
pappso::masschroq::CborOutputStream::writeProjectParameters
void writeProjectParameters(const pappso::ProjectParameters &project_parameters)
Definition cboroutputstream.cpp:427
pappso::masschroq::CborOutputStream::writeActionBegin
void writeActionBegin(const QString &operation)
Definition cboroutputstream.cpp:67
pappso::masschroq::JsonInput::computeIsotopologues
void computeIsotopologues(double ni_ratio)
Definition jsoninput.cpp:470
pappso::masschroq::JsonInput::readAction
void readAction(CborOutputStream &cbor_output)
Definition jsoninput.cpp:495
pappso::masschroq::JsonInput::JsonInput
JsonInput(pappso::UiMonitorInterface &ui_monitor, const QString &tmp_dir_name, const QJsonDocument &json_doc)
Definition jsoninput.cpp:42
pappso::masschroq::JsonInput::action
void action(CborOutputStream &cbor_output)
Definition jsoninput.cpp:54
pappso::masschroq::JsonInput::documentFind
const QJsonValue documentFind(const QString &key1, const QString &key2) const
Definition jsoninput.cpp:111
pappso::masschroq::Utils::getVersion
static QString getVersion()
Definition utils.cpp:37
pappso::masschroq::ProteinSp
std::shared_ptr< Protein > ProteinSp
Definition protein.h:39
pappso::masschroq::MsRunPeptideListSp
std::shared_ptr< MsRunPeptideList > MsRunPeptideListSp
Definition msrunpeptidelist.h:47
pappso::masschroq::PeptideSp
std::shared_ptr< Peptide > PeptideSp
Definition peptide.h:46
pappso::masschroq::MsRunSp
std::shared_ptr< MsRun > MsRunSp
Definition msrun.h:44
pappso::MsRunReaderSPtr
std::shared_ptr< MsRunReader > MsRunReaderSPtr
Definition msrunreader.h:57
pappso::ProjectParamCategory::quantification
@ quantification
quantification