Loading...
Searching...
No Matches
quantificationmethod.cpp
Go to the documentation of this file.
/**
* \file pappsomspp/masschroq/quantificationmethod.cpp
* \date 24/10/2024
* \author Olivier Langella
* \brief store parameters related to peak detection and quantification
*/
/*******************************************************************************
* Copyright (c) 2024 Olivier Langella
*<Olivier.Langella@universite-paris-saclay.fr>.
*
* This file is part of MassChroQ.
*
* MassChroQ is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* MassChroQ is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with MassChroQ. If not, see <http://www.gnu.org/licenses/>.
*
******************************************************************************/
#include "types.h"
#include "quantificationmethod.h"
#include "utils.h"
#include "pappsomspp/core/pappsoexception.h"
#include "pappsomspp/core/exception/exceptionnotfound.h"
#include "pappsomspp/core/processing/detection/tracedetectionzivy.h"
namespace pappso
{
masschroq::QuantificationMethod::QuantificationMethod(const QString &id) : m_id(id)
{
// by default
qDebug();
mp_xicExtractionLowerPrecisionPtr = PrecisionFactory::getPpmInstance(10);
mp_xicExtractionUppersPrecisionPtr = PrecisionFactory::getPpmInstance(10);
m_isotopeMinimumRatio = 0.8;
qDebug();
setXicFilter(std::make_shared<FilterMorphoAntiSpike>(5));
qDebug();
mcsp_traceDetectionInterfaceCstSPtr = std::make_shared<TraceDetectionZivy>(1, 3, 2, 5000, 3000);
qDebug();
}
masschroq::QuantificationMethod::QuantificationMethod(const masschroq::QuantificationMethod &other)
: m_id(other.m_id)
{
m_isotopeMinimumRatio = other.m_isotopeMinimumRatio;
m_matchBetweenRun = other.m_matchBetweenRun;
m_xicExtractMethod = other.m_xicExtractMethod;
m_xicFilterSuite = other.m_xicFilterSuite;
mcsp_traceDetectionInterfaceCstSPtr = other.mcsp_traceDetectionInterfaceCstSPtr;
mp_xicExtractionLowerPrecisionPtr = other.mp_xicExtractionLowerPrecisionPtr;
mp_xicExtractionUppersPrecisionPtr = other.mp_xicExtractionUppersPrecisionPtr;
m_xicExtractionRetentionTimeAroundTarget = other.m_xicExtractionRetentionTimeAroundTarget;
}
masschroq::QuantificationMethod::~QuantificationMethod()
{
}
const QString &
masschroq::QuantificationMethod::getId() const
{
return m_id;
}
double
masschroq::QuantificationMethod::getXicExtractionRtRange() const
{
return m_xicExtractionRetentionTimeAroundTarget;
}
void
masschroq::QuantificationMethod::setXicExtractionRtRange(double rt_range)
{
m_xicExtractionRetentionTimeAroundTarget = rt_range;
}
bool
masschroq::QuantificationMethod::getMatchBetweenRun() const
{
return m_matchBetweenRun;
}
void
masschroq::QuantificationMethod::setIsotopeMinimumRatio(double ratio)
{
if((ratio < 1) && (ratio >= 0))
{
m_isotopeMinimumRatio = ratio;
}
}
double
masschroq::QuantificationMethod::getIsotopeMinimumRatio() const
{
return m_isotopeMinimumRatio;
}
void
masschroq::QuantificationMethod::setXicFilter(const FilterNameInterfaceSPtr &filter)
{
m_xicFilterSuite = std::make_shared<FilterSuiteString>(filter.get()->toString());
}
void
masschroq::QuantificationMethod::addXicFilter(const FilterNameInterfaceSPtr &filter)
{
if(m_xicFilterSuite.get() == nullptr)
{
m_xicFilterSuite = std::make_shared<FilterSuiteString>(filter.get()->toString());
}
else
{
m_xicFilterSuite.get()->addFilter(filter);
}
}
const FilterSuiteStringSPtr &
masschroq::QuantificationMethod::getFilterSuiteStringSPtr() const
{
return m_xicFilterSuite;
}
PrecisionPtr
masschroq::QuantificationMethod::getXicExtractionMeanPrecisionPtr() const
{
if(mp_xicExtractionLowerPrecisionPtr->unit() == Enums::PrecisionUnit::ppm)
{
return PrecisionFactory::getPpmInstance((mp_xicExtractionLowerPrecisionPtr->getNominal() +
mp_xicExtractionUppersPrecisionPtr->getNominal()) /
2);
}
return PrecisionFactory::getDaltonInstance((mp_xicExtractionLowerPrecisionPtr->getNominal() +
mp_xicExtractionUppersPrecisionPtr->getNominal()) /
2);
}
Enums::XicExtractMethod
masschroq::QuantificationMethod::getXicExtractMethod() const
{
return m_xicExtractMethod;
}
void
masschroq::QuantificationMethod::setTraceDetectionInterfaceCstSPtr(
const TraceDetectionInterfaceCstSPtr &detection)
{
mcsp_traceDetectionInterfaceCstSPtr = detection;
}
void
masschroq::QuantificationMethod::setXicExtractionLowerPrecisionPtr(PrecisionPtr precision)
{
mp_xicExtractionLowerPrecisionPtr = precision;
}
void
masschroq::QuantificationMethod::setXicExtractionUpperPrecisionPtr(PrecisionPtr precision)
{
mp_xicExtractionUppersPrecisionPtr = precision;
}
void
masschroq::QuantificationMethod::setXicExtractMethod(Enums::XicExtractMethod method)
{
m_xicExtractMethod = method;
}
const FilterNameInterfaceSPtr
masschroq::QuantificationMethod::getXicFilter() const
{
return m_xicFilterSuite;
}
const MzRange
masschroq::QuantificationMethod::getXicExtractionMzRange(double mz) const
{
return MzRange(mz, mp_xicExtractionLowerPrecisionPtr, mp_xicExtractionUppersPrecisionPtr);
}
const TraceDetectionInterfaceCstSPtr &
masschroq::QuantificationMethod::getTraceDetectionInterfaceCstSPtr() const
{
return mcsp_traceDetectionInterfaceCstSPtr;
}
ProjectParameters
masschroq::QuantificationMethod::getProjectParameters() const
{
ProjectParameters parameters;
ProjectParam project_param({ProjectParamCategory::quantification, "", QVariant()});
// xic_type="max"
project_param.name = "mcq_xic_extraction_type";
project_param.value.setValue(masschroq::Utils::enumToString(m_xicExtractMethod));
parameters.setProjectParam(project_param);
project_param.name = "mcq_mbr";
project_param.value.setValue(getMatchBetweenRun());
parameters.setProjectParam(project_param);
project_param.name = "mcq_isotope_minimum_ratio";
project_param.value.setValue(getIsotopeMinimumRatio());
parameters.setProjectParam(project_param);
if(mp_xicExtractionLowerPrecisionPtr->unit() == Enums::PrecisionUnit::ppm)
{
//<!--For XIC extraction on Da use: mz_range-->
//<ppm_range min="10" max="10"/>
project_param.name = "mcq_xic_ppm_range_min";
project_param.value.setValue(mp_xicExtractionLowerPrecisionPtr->getNominal());
parameters.setProjectParam(project_param);
project_param.name = "mcq_xic_ppm_range_max";
project_param.value.setValue(mp_xicExtractionUppersPrecisionPtr->getNominal());
parameters.setProjectParam(project_param);
}
if(mp_xicExtractionLowerPrecisionPtr->unit() == Enums::PrecisionUnit::dalton)
{
//<!--For XIC extraction on Da use: mz_range-->
//<ppm_range min="10" max="10"/>
project_param.name = "mcq_xic_mz_range_min";
project_param.value.setValue(mp_xicExtractionLowerPrecisionPtr->getNominal());
parameters.setProjectParam(project_param);
project_param.name = "mcq_xic_mz_range_max";
project_param.value.setValue(mp_xicExtractionUppersPrecisionPtr->getNominal());
parameters.setProjectParam(project_param);
}
project_param.name = "mcq_xic_pre_filter";
if(m_xicFilterSuite.get() != nullptr)
project_param.value.setValue(m_xicFilterSuite.get()->toString());
else
project_param.value.setValue("");
parameters.setProjectParam(project_param);
const TraceDetectionZivy *detection_zivy =
dynamic_cast<const TraceDetectionZivy *>(mcsp_traceDetectionInterfaceCstSPtr.get());
if(detection_zivy != nullptr)
{
project_param.name = "mcq_detection_zivy";
project_param.value.setValue(QString("%1 %2 %3 %4 %5")
.arg(detection_zivy->getSmoothingHalfEdgeWindows())
.arg(detection_zivy->getMinMaxHalfEdgeWindows())
.arg(detection_zivy->getMaxMinHalfEdgeWindows())
.arg(detection_zivy->getDetectionThresholdOnMinmax())
.arg(detection_zivy->getDetectionThresholdOnMaxmin()));
parameters.setProjectParam(project_param);
}
return parameters;
}
QJsonObject
masschroq::QuantificationMethod::getJsonObject() const
{
QJsonObject method;
qDebug();
QString xic_type = Utils::enumToString(m_xicExtractMethod);
if(mp_xicExtractionUppersPrecisionPtr == nullptr)
{
throw PappsoException(
"mp_xicExtractionUppersPrecisionPtr == "
"nullptr");
}
if(mp_xicExtractionLowerPrecisionPtr == nullptr)
{
throw PappsoException(
"mp_xicExtractionLowerPrecisionPtr == "
"nullptr");
}
qDebug();
QJsonObject precision;
precision.insert("unit", Utils::enumToString(mp_xicExtractionUppersPrecisionPtr->unit()));
precision.insert("down", mp_xicExtractionLowerPrecisionPtr->getNominal());
precision.insert("up", mp_xicExtractionUppersPrecisionPtr->getNominal());
QJsonObject extraction;
extraction.insert("integration", xic_type);
extraction.insert("precision", precision);
method.insert("extraction", extraction);
method.insert("match_between_run", m_matchBetweenRun);
method.insert("isotope_minimum_ratio", m_isotopeMinimumRatio);
method.insert("rt_range", m_xicExtractionRetentionTimeAroundTarget);
// xic_filters
if(m_xicFilterSuite.get() == nullptr)
{
throw PappsoException(
"m_xicFilterSuite.get() == "
"nullptr");
}
method.insert("pre_filter", m_xicFilterSuite.get()->toString());
const TraceDetectionZivy *detection_zivy =
dynamic_cast<const TraceDetectionZivy *>(getTraceDetectionInterfaceCstSPtr().get());
if(detection_zivy == nullptr)
{
throw PappsoException(
"m_quantificationMethod.getTraceDetectionInterfaceCstSPtr().get() == "
"nullptr");
}
QJsonObject detection;
detection.insert("type", "zivy");
detection.insert("meanfilter", (int)detection_zivy->getSmoothingHalfEdgeWindows());
detection.insert("minmax", (int)detection_zivy->getMinMaxHalfEdgeWindows());
detection.insert("maxmin", (int)detection_zivy->getMaxMinHalfEdgeWindows());
detection.insert("threshold_on_max", detection_zivy->getDetectionThresholdOnMinmax());
detection.insert("threshold_on_min", detection_zivy->getDetectionThresholdOnMaxmin());
method.insert("detection", detection);
return method;
}
void
masschroq::QuantificationMethod::setJsonObject(const QJsonObject &quantification_method)
{
m_matchBetweenRun = quantification_method.value("match_between_run").toBool();
m_isotopeMinimumRatio = quantification_method.value("isotope_minimum_ratio").toDouble();
QString filter_str = quantification_method.value("pre_filter").toString();
qDebug() << filter_str;
if(!filter_str.isEmpty())
{
FilterNameInterfaceSPtr filter_sp = std::make_shared<FilterSuiteString>(filter_str);
addXicFilter(filter_sp);
qDebug() << filter_str;
}
QJsonObject extraction = quantification_method.value("extraction").toObject();
QJsonValue rt_range = extraction.value("rt_range");
if(!rt_range.isUndefined())
{
setXicExtractionRtRange(rt_range.toDouble());
}
QString integration = extraction.value("integration").toString();
if(integration == "sum")
{
setXicExtractMethod(Enums::XicExtractMethod::sum);
}
else if(integration == "max")
{
setXicExtractMethod(Enums::XicExtractMethod::max);
}
else
{
throw ExceptionNotFound(QObject::tr("missing "
"masschroq_methods>quantification_method>extraction>"
"integration %1 value")
.arg(integration));
}
QJsonObject precision = extraction.value("precision").toObject();
qDebug() << precision.value("down").toDouble();
qDebug() << precision.value("up").toDouble();
if(precision.value("unit").toString() == "dalton")
{
setXicExtractionLowerPrecisionPtr(
PrecisionFactory::getDaltonInstance(precision.value("down").toDouble()));
setXicExtractionUpperPrecisionPtr(
PrecisionFactory::getDaltonInstance(precision.value("up").toDouble()));
}
else if(precision.value("unit").toString() == "ppm")
{
setXicExtractionLowerPrecisionPtr(
PrecisionFactory::getPpmInstance(precision.value("down").toDouble()));
setXicExtractionUpperPrecisionPtr(
PrecisionFactory::getPpmInstance(precision.value("up").toDouble()));
}
else
{
throw ExceptionNotFound(
QObject::tr("missing "
"masschroq_methods>quantification_method>extraction>precision>"
"unit"));
}
QJsonObject detection = quantification_method.value("detection").toObject();
if(detection.value("type").toString() == "zivy")
{
std::shared_ptr<TraceDetectionZivy> sp_detection_zivy =
std::make_shared<TraceDetectionZivy>(detection.value("meanfilter").toInt(),
detection.value("minmax").toInt(),
detection.value("maxmin").toInt(),
detection.value("threshold_on_max").toInt(),
detection.value("threshold_on_min").toInt());
setTraceDetectionInterfaceCstSPtr(sp_detection_zivy);
}
else
{
throw ExceptionNotFound(
QObject::tr("only masschroq_methods>quantification_method>detection>type == zivy "
"allowed"));
}
}
PrecisionPtr
masschroq::QuantificationMethod::getXicExtractionLowerPrecisionPtr() const
{
return mp_xicExtractionLowerPrecisionPtr;
}
PrecisionPtr
masschroq::QuantificationMethod::getXicExtractionUppersPrecisionPtr() const
{
return mp_xicExtractionUppersPrecisionPtr;
}
void
masschroq::QuantificationMethod::setMatchBetweenRun(bool is_match)
{
m_matchBetweenRun = is_match;
}
} // namespace pappso
pappso::ExceptionNotFound
Definition exceptionnotfound.h:32
pappso::MzRange
Definition mzrange.h:46
pappso::PappsoException
Definition pappsoexception.h:41
pappso::PrecisionFactory::getPpmInstance
static PrecisionPtr getPpmInstance(pappso_double value)
get a ppm precision pointer
Definition precision.cpp:155
pappso::PrecisionFactory::getDaltonInstance
static PrecisionPtr getDaltonInstance(pappso_double value)
get a Dalton precision pointer
Definition precision.cpp:136
pappso::ProjectParameters
Definition projectparameters.h:66
pappso::ProjectParameters::setProjectParam
void setProjectParam(const ProjectParam &param)
Definition projectparameters.cpp:246
pappso::TraceDetectionZivy
Definition tracedetectionzivy.h:38
pappso::TraceDetectionZivy::getMinMaxHalfEdgeWindows
unsigned int getMinMaxHalfEdgeWindows() const
Definition tracedetectionzivy.cpp:96
pappso::TraceDetectionZivy::getSmoothingHalfEdgeWindows
unsigned int getSmoothingHalfEdgeWindows() const
Definition tracedetectionzivy.cpp:85
pappso::TraceDetectionZivy::getDetectionThresholdOnMinmax
double getDetectionThresholdOnMinmax() const
Definition tracedetectionzivy.cpp:101
pappso::TraceDetectionZivy::getDetectionThresholdOnMaxmin
double getDetectionThresholdOnMaxmin() const
Definition tracedetectionzivy.cpp:106
pappso::TraceDetectionZivy::getMaxMinHalfEdgeWindows
unsigned int getMaxMinHalfEdgeWindows() const
Definition tracedetectionzivy.cpp:90
pappso::masschroq::QuantificationMethod
Definition quantificationmethod.h:52
pappso::masschroq::QuantificationMethod::mp_xicExtractionUppersPrecisionPtr
pappso::PrecisionPtr mp_xicExtractionUppersPrecisionPtr
Definition quantificationmethod.h:118
pappso::masschroq::QuantificationMethod::getTraceDetectionInterfaceCstSPtr
const pappso::TraceDetectionInterfaceCstSPtr & getTraceDetectionInterfaceCstSPtr() const
Definition quantificationmethod.cpp:199
pappso::masschroq::QuantificationMethod::getXicExtractMethod
Enums::XicExtractMethod getXicExtractMethod() const
Definition quantificationmethod.cpp:155
pappso::masschroq::QuantificationMethod::m_xicFilterSuite
pappso::FilterSuiteStringSPtr m_xicFilterSuite
the xic filters
Definition quantificationmethod.h:133
pappso::masschroq::QuantificationMethod::setXicExtractionUpperPrecisionPtr
void setXicExtractionUpperPrecisionPtr(pappso::PrecisionPtr precision)
Definition quantificationmethod.cpp:174
pappso::masschroq::QuantificationMethod::getXicExtractionMeanPrecisionPtr
pappso::PrecisionPtr getXicExtractionMeanPrecisionPtr() const
Definition quantificationmethod.cpp:140
pappso::masschroq::QuantificationMethod::mp_xicExtractionLowerPrecisionPtr
pappso::PrecisionPtr mp_xicExtractionLowerPrecisionPtr
Definition quantificationmethod.h:117
pappso::masschroq::QuantificationMethod::getXicExtractionUppersPrecisionPtr
pappso::PrecisionPtr getXicExtractionUppersPrecisionPtr() const
Definition quantificationmethod.cpp:442
pappso::masschroq::QuantificationMethod::mcsp_traceDetectionInterfaceCstSPtr
pappso::TraceDetectionInterfaceCstSPtr mcsp_traceDetectionInterfaceCstSPtr
the peak detection method for this quantification
Definition quantificationmethod.h:137
pappso::masschroq::QuantificationMethod::setIsotopeMinimumRatio
void setIsotopeMinimumRatio(double ratio)
Definition quantificationmethod.cpp:98
pappso::masschroq::QuantificationMethod::getXicExtractionRtRange
double getXicExtractionRtRange() const
Definition quantificationmethod.cpp:80
pappso::masschroq::QuantificationMethod::m_xicExtractionRetentionTimeAroundTarget
double m_xicExtractionRetentionTimeAroundTarget
set the retention time range in seconds around the target rt
Definition quantificationmethod.h:129
pappso::masschroq::QuantificationMethod::m_matchBetweenRun
bool m_matchBetweenRun
Definition quantificationmethod.h:139
pappso::masschroq::QuantificationMethod::setJsonObject
void setJsonObject(const QJsonObject &json_object)
Definition quantificationmethod.cpp:350
pappso::masschroq::QuantificationMethod::m_xicExtractMethod
Enums::XicExtractMethod m_xicExtractMethod
Definition quantificationmethod.h:115
pappso::masschroq::QuantificationMethod::setXicExtractMethod
void setXicExtractMethod(Enums::XicExtractMethod method)
Definition quantificationmethod.cpp:180
pappso::masschroq::QuantificationMethod::QuantificationMethod
QuantificationMethod(const QString &id)
Definition quantificationmethod.cpp:39
pappso::masschroq::QuantificationMethod::getProjectParameters
pappso::ProjectParameters getProjectParameters() const
Definition quantificationmethod.cpp:205
pappso::masschroq::QuantificationMethod::getXicExtractionLowerPrecisionPtr
pappso::PrecisionPtr getXicExtractionLowerPrecisionPtr() const
Definition quantificationmethod.cpp:436
pappso::masschroq::QuantificationMethod::setMatchBetweenRun
void setMatchBetweenRun(bool is_match)
Definition quantificationmethod.cpp:448
pappso::masschroq::QuantificationMethod::setXicFilter
void setXicFilter(const pappso::FilterNameInterfaceSPtr &filter)
Definition quantificationmethod.cpp:113
pappso::masschroq::QuantificationMethod::getMatchBetweenRun
bool getMatchBetweenRun() const
Definition quantificationmethod.cpp:92
pappso::masschroq::QuantificationMethod::addXicFilter
void addXicFilter(const pappso::FilterNameInterfaceSPtr &filter)
Definition quantificationmethod.cpp:120
pappso::masschroq::QuantificationMethod::getFilterSuiteStringSPtr
const FilterSuiteStringSPtr & getFilterSuiteStringSPtr() const
Definition quantificationmethod.cpp:133
pappso::masschroq::QuantificationMethod::setXicExtractionRtRange
void setXicExtractionRtRange(double rt_range)
Definition quantificationmethod.cpp:86
pappso::masschroq::QuantificationMethod::m_id
const QString m_id
Definition quantificationmethod.h:114
pappso::masschroq::QuantificationMethod::getXicExtractionMzRange
const pappso::MzRange getXicExtractionMzRange(double mz) const
Definition quantificationmethod.cpp:192
pappso::masschroq::QuantificationMethod::m_isotopeMinimumRatio
double m_isotopeMinimumRatio
the minimum percentage of theoretical intensity of the isotope pattern to compute
Definition quantificationmethod.h:144
pappso::masschroq::QuantificationMethod::getIsotopeMinimumRatio
double getIsotopeMinimumRatio() const
Definition quantificationmethod.cpp:107
pappso::masschroq::QuantificationMethod::~QuantificationMethod
virtual ~QuantificationMethod()
Definition quantificationmethod.cpp:69
pappso::masschroq::QuantificationMethod::getJsonObject
QJsonObject getJsonObject() const
Definition quantificationmethod.cpp:279
pappso::masschroq::QuantificationMethod::setXicExtractionLowerPrecisionPtr
void setXicExtractionLowerPrecisionPtr(pappso::PrecisionPtr precision)
Definition quantificationmethod.cpp:168
pappso::masschroq::QuantificationMethod::getId
const QString & getId() const
Definition quantificationmethod.cpp:74
pappso::masschroq::QuantificationMethod::setTraceDetectionInterfaceCstSPtr
void setTraceDetectionInterfaceCstSPtr(const pappso::TraceDetectionInterfaceCstSPtr &detection)
Definition quantificationmethod.cpp:161
pappso::masschroq::QuantificationMethod::getXicFilter
const pappso::FilterNameInterfaceSPtr getXicFilter() const
Definition quantificationmethod.cpp:186
pappso::masschroq::Utils::enumToString
static QString enumToString(PeakQualityCategory peak_category)
Convenience function to return a string describing the specglob alingment type.
Definition utils.cpp:44
exceptionnotfound.h
types.h
utils.h
pappso::Enums::XicExtractMethod
XicExtractMethod
Definition types.h:278
pappso::Enums::XicExtractMethod::sum
@ sum
sum of intensities
Definition types.h:279
pappso::Enums::XicExtractMethod::max
@ max
maximum of intensities
Definition types.h:280
pappso::Enums::PrecisionUnit::ppm
@ ppm
Definition types.h:99
pappso::Enums::PrecisionUnit::dalton
@ dalton
Definition types.h:98
pappso
tries to keep as much as possible monoisotopes, removing any possible C13 peaks and changes multichar...
Definition aa.cpp:39
pappso::FilterSuiteStringSPtr
std::shared_ptr< FilterSuiteString > FilterSuiteStringSPtr
Definition filtersuitestring.h:83
pappso::TraceDetectionInterfaceCstSPtr
std::shared_ptr< const TraceDetectionInterface > TraceDetectionInterfaceCstSPtr
Definition tracedetectioninterface.h:35
pappso::ProjectParamCategory::quantification
@ quantification
quantification
Definition projectparameters.h:49
pappso::ProjectParamCategory::filter
@ filter
concerning filters (psm, peptide, protein validation)
Definition projectparameters.h:48
pappso::FilterNameInterfaceSPtr
std::shared_ptr< FilterNameInterface > FilterNameInterfaceSPtr
Definition filternameinterface.h:59
pappso::PrecisionPtr
const PrecisionBase * PrecisionPtr
Definition precision.h:122
pappsoexception.h
quantificationmethod.h
pappso::ProjectParam
Definition projectparameters.h:54
pappso::ProjectParam::name
QString name
Definition projectparameters.h:58
tracedetectionzivy.h