CosmicRayTaggingMonitoringTool class. More...

#include <CosmicRayTaggingMonitoringTool.h>

Inheritance diagram for lar_content::CosmicRayTaggingMonitoringTool:

Public Member Functions
	CosmicRayTaggingMonitoringTool ()
	Default constructor. More...

void	FindAmbiguousPfos (const pandora::PfoList &parentCosmicRayPfos, pandora::PfoList &ambiguousPfos, const MasterAlgorithm *const pAlgorithm)
	Find the list of ambiguous pfos (could represent cosmic-ray muons or neutrinos) More...

Private Types
enum	Classification { CR_MUON, CR_OTHER, TARGET, FRAGMENTED, ABSORBED, MIXED, SPARSE, UNCLASSIFIED }

typedef std::map< const pandora::ParticleFlowObject *, float >	PfoToFloatMap

typedef std::map< const pandora::ParticleFlowObject *, Classification >	PfoClassificationMap

Private Member Functions
void	CalculatePfoMetrics (const LArMCParticleHelper::PfoToMCParticleHitSharingMap &hitSharingMap, const LArMCParticleHelper::PfoContributionMap &pfoToCaloHitListMap, const LArMCParticleHelper::MCContributionMapVector &targetsToGoodHitsMaps, PfoToFloatMap &pfoSignificanceMap, PfoToFloatMap &pfoPurityMap, PfoClassificationMap &pfoClassificationMap) const
	Calculate metrics to classify Pfos based on the target reconstructable MCParticles with which they share hits. More...

bool	IsMainMCParticleMuon (const pandora::ParticleFlowObject *const pPfo) const
	Returns true if the main MCParticle of the supplied Pfo is a muon. More...

Classification	ClassifyPfo (const unsigned int &nHits, const float &significance, const float &purity, const bool isMuon) const
	Classify a pfo given some metrics. More...

LArFormattingHelper::Color	GetClassificationColor (const Classification &classification) const
	Returns a unique color for each possible Pfo classification. More...

std::string	GetClassificationName (const Classification &classification) const
	Returns a string for each classification. More...

void	PrintPfoTable (const pandora::PfoVector &orderedPfoVector, const LArMCParticleHelper::PfoContributionMap &pfoToReconstructable2DHitsMap, const PfoToFloatMap &pfoPurityMap, const PfoToFloatMap &pfoSignificanceMap, const PfoClassificationMap &pfoClassificationMap, const pandora::PfoList &ambiguousPfos) const
	Prints a table detailing all input Pfos and their classifications. More...

pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)
	Read settings. More...

Private Attributes
LArMCParticleHelper::PrimaryParameters	m_parameters
	Parameters used to decide when an MCParticle is reconstructable. More...

unsigned int	m_minHitsToConsiderTagging
	The minimum number of hits to consider a Pfo for tagging. More...

float	m_minPurity
	The minimum purity to consider a Pfo as "pure". More...

float	m_minImpurity
	The minimum impurity to consider a Pfo as "impure". More...

float	m_minSignificance
	The minimum significance to consider a Pfo as "significant". More...

std::string	m_caloHitList2D
	The 2D calo hit list. More...

Detailed Description

CosmicRayTaggingMonitoringTool class.

Definition at line 24 of file CosmicRayTaggingMonitoringTool.h.

Member Typedef Documentation

typedef std::map<const pandora::ParticleFlowObject *, Classification> lar_content::CosmicRayTaggingMonitoringTool::PfoClassificationMap

private

Definition at line 51 of file CosmicRayTaggingMonitoringTool.h.

typedef std::map<const pandora::ParticleFlowObject *, float> lar_content::CosmicRayTaggingMonitoringTool::PfoToFloatMap

private

Definition at line 50 of file CosmicRayTaggingMonitoringTool.h.

Member Enumeration Documentation

enum lar_content::CosmicRayTaggingMonitoringTool::Classification

private

Enumerator
CR_MUON
CR_OTHER
TARGET
FRAGMENTED
ABSORBED
MIXED
SPARSE
UNCLASSIFIED

Definition at line 38 of file CosmicRayTaggingMonitoringTool.h.

     {
         CR_MUON,
         CR_OTHER,
         TARGET,
         FRAGMENTED,
         ABSORBED,
         MIXED,
         SPARSE,
         UNCLASSIFIED
     };

Constructor & Destructor Documentation

lar_content::CosmicRayTaggingMonitoringTool::CosmicRayTaggingMonitoringTool ( )

Default constructor.

Definition at line 24 of file CosmicRayTaggingMonitoringTool.cc.

                                                                :
     m_minHitsToConsiderTagging(15),
     m_minPurity(0.95),
     m_minImpurity(0.95),
     m_minSignificance(0.1)
 {
 }

Member Function Documentation

void lar_content::CosmicRayTaggingMonitoringTool::CalculatePfoMetrics	(	const LArMCParticleHelper::PfoToMCParticleHitSharingMap &	hitSharingMap,
		const LArMCParticleHelper::PfoContributionMap &	pfoToCaloHitListMap,
		const LArMCParticleHelper::MCContributionMapVector &	targetsToGoodHitsMaps,
		PfoToFloatMap &	pfoSignificanceMap,
		PfoToFloatMap &	pfoPurityMap,
		PfoClassificationMap &	pfoClassificationMap
	)		const

private

Calculate metrics to classify Pfos based on the target reconstructable MCParticles with which they share hits.

Parameters

hitSharingMap	input mapping from Pfos to MCParticles + number of shared hits pairs
pfoToCaloHitListMap	input mapping from Pfos to their reconstructable 2D hits
targetsToGoodHitsMaps	input mapping from target reconstructable MCParticles (those which shouldn't be tagged) to their good hits
pfoSignificanceMap	output mapping from Pfos to their target significance
pfoPurityMap	output mapping from Pfos to their target purities
pfoClassificationMap	output mapping from Pfos to their classification

Definition at line 103 of file CosmicRayTaggingMonitoringTool.cc.

 {
     PfoVector sortedPfos;
     for (const auto &mapEntry : hitSharingMap)
         sortedPfos.push_back(mapEntry.first);
     std::sort(sortedPfos.begin(), sortedPfos.end(), LArPfoHelper::SortByNHits);
 
     for (const ParticleFlowObject *const pPfo : sortedPfos)
     {
         if (pfoToCaloHitListMap.find(pPfo) == pfoToCaloHitListMap.end())
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         const unsigned int n2DHits(pfoToCaloHitListMap.at(pPfo).size());
         float significance(0);
         float purity(0);
 
         if (n2DHits != 0)
         {
             // Sum over all target/shared hits pairs
             for (const LArMCParticleHelper::MCParticleCaloHitListPair &targetHitsShared : hitSharingMap.at(pPfo))
             {
                 bool foundTarget(false);
                 unsigned int nMCHits(std::numeric_limits<unsigned int>::max());
 
                 // ATTN This map is unordered, but this does not impact search for specific target hit
                 for (const LArMCParticleHelper::MCContributionMap &mcContributionMap : targetsToGoodHitsMaps)
                 {
                     if (mcContributionMap.find(targetHitsShared.first) != mcContributionMap.end())
                     {
                         foundTarget = true;
                         nMCHits = mcContributionMap.at(targetHitsShared.first).size();
                         break;
                     }
                 }
 
                 if (!foundTarget)
                     continue;
 
                 significance += static_cast<float>(targetHitsShared.second.size()) / static_cast<float>(nMCHits);
                 purity += static_cast<float>(targetHitsShared.second.size()) / static_cast<float>(n2DHits);
             }
         }
 
         if (!pfoSignificanceMap.insert(PfoToFloatMap::value_type(pPfo, significance)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 
         if (!pfoPurityMap.insert(PfoToFloatMap::value_type(pPfo, purity)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 
         Classification classification(this->ClassifyPfo(n2DHits, significance, purity, this->IsMainMCParticleMuon(pPfo)));
         if (!pfoClassificationMap.insert(PfoClassificationMap::value_type(pPfo, classification)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
     }
 }

CosmicRayTaggingMonitoringTool::Classification lar_content::CosmicRayTaggingMonitoringTool::ClassifyPfo	(	const unsigned int &	nHits,
		const float &	significance,
		const float &	purity,
		const bool	isMuon
	)		const

private

Classify a pfo given some metrics.

Parameters

nHits	the number of reconstructable hits in the Pfo
significance	the number of target MCParticles represented by the Pfo
purity	the fraction of reconstructable hits in the Pfo that come from a target MCParticle
isMuon	is the main MCParticle that the Pfo represents a muon?

Definition at line 178 of file CosmicRayTaggingMonitoringTool.cc.

 {
     if (nHits < m_minHitsToConsiderTagging)
         return SPARSE;
 
     bool isPure(purity > m_minPurity);
     bool isImpure((1 - purity) > m_minImpurity);
     bool isSignificant(significance > m_minSignificance);
 
     if (!isPure && !isImpure)
         return MIXED;
 
     if (isPure && isSignificant)
         return TARGET;
 
     if (isPure && !isSignificant)
         return FRAGMENTED;
 
     if (!isPure && isSignificant)
         return ABSORBED;
 
     if (!isPure && !isSignificant && isMuon)
         return CR_MUON;
 
     // !isPure && !isSignificant && !isMuon
     return CR_OTHER;
 }

void lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos	(	const pandora::PfoList &	parentCosmicRayPfos,
		pandora::PfoList &	ambiguousPfos,
		const MasterAlgorithm *const	pAlgorithm
	)

virtual

Find the list of ambiguous pfos (could represent cosmic-ray muons or neutrinos)

Parameters

parentCosmicRayPfos	the list of parent cosmic-ray pfos
ambiguousPfos	to receive the list of ambiguous pfos
pAlgorithm	the address of this master algorithm

Implements lar_content::CosmicRayTaggingBaseTool.

Definition at line 34 of file CosmicRayTaggingMonitoringTool.cc.

 {
     if (this->GetPandora().GetSettings()->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     const MCParticleList *pMCParticleList = nullptr;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*pAlgorithm, pMCParticleList));
 
     const CaloHitList *pCaloHitList = nullptr;
     PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*pAlgorithm, m_caloHitList2D, pCaloHitList));
 
     // Identify reconstructable MCParticles, and get mappings to their good hits
     LArMCParticleHelper::MCContributionMap nuMCParticlesToGoodHitsMap;
     LArMCParticleHelper::MCContributionMap beamMCParticlesToGoodHitsMap;
     LArMCParticleHelper::MCContributionMap crMCParticlesToGoodHitsMap;
 
     LArMCParticleHelper::SelectReconstructableMCParticles(
         pMCParticleList, pCaloHitList, m_parameters, LArMCParticleHelper::IsBeamNeutrinoFinalState, nuMCParticlesToGoodHitsMap);
     LArMCParticleHelper::SelectReconstructableMCParticles(
         pMCParticleList, pCaloHitList, m_parameters, LArMCParticleHelper::IsBeamParticle, beamMCParticlesToGoodHitsMap);
     LArMCParticleHelper::SelectReconstructableMCParticles(
         pMCParticleList, pCaloHitList, m_parameters, LArMCParticleHelper::IsCosmicRay, crMCParticlesToGoodHitsMap);
 
     // Get the hit sharing maps between Pfos and reconstructable MCParticles
     LArMCParticleHelper::MCContributionMapVector mcParticlesToGoodHitsMaps(
         {nuMCParticlesToGoodHitsMap, beamMCParticlesToGoodHitsMap, crMCParticlesToGoodHitsMap});
 
     LArMCParticleHelper::PfoContributionMap pfoToReconstructable2DHitsMap;
     LArMCParticleHelper::GetPfoToReconstructable2DHitsMap(
         parentCosmicRayPfos, mcParticlesToGoodHitsMaps, pfoToReconstructable2DHitsMap, m_parameters.m_foldBackHierarchy);
 
     LArMCParticleHelper::PfoToMCParticleHitSharingMap pfoToMCParticleHitSharingMap;
     LArMCParticleHelper::MCParticleToPfoHitSharingMap mcParticleToPfoHitSharingMap;
     LArMCParticleHelper::GetPfoMCParticleHitSharingMaps(
         pfoToReconstructable2DHitsMap, mcParticlesToGoodHitsMaps, pfoToMCParticleHitSharingMap, mcParticleToPfoHitSharingMap);
 
     // Calculate the purity and significane and classification of each Pfo
     PfoToFloatMap pfoSignificanceMap;
     PfoToFloatMap pfoPurityMap;
     PfoClassificationMap pfoClassificationMap;
     LArMCParticleHelper::MCContributionMapVector targetsToGoodHitsMaps({nuMCParticlesToGoodHitsMap, beamMCParticlesToGoodHitsMap});
     this->CalculatePfoMetrics(pfoToMCParticleHitSharingMap, pfoToReconstructable2DHitsMap, targetsToGoodHitsMaps, pfoSignificanceMap,
         pfoPurityMap, pfoClassificationMap);
 
     // -------------------------------------------------------------------------------------------------------------------------------------
 
     // Print the monte-carlo information for this event
     MCParticleVector orderedMCParticleVector;
     LArMonitoringHelper::GetOrderedMCParticleVector(mcParticlesToGoodHitsMaps, orderedMCParticleVector);
 
     LArFormattingHelper::PrintHeader("MC : Reconstructable neutrino final state particles");
     LArMonitoringHelper::PrintMCParticleTable(nuMCParticlesToGoodHitsMap, orderedMCParticleVector);
 
     LArFormattingHelper::PrintHeader("MC : Reconstructable primary beam particles");
     LArMonitoringHelper::PrintMCParticleTable(beamMCParticlesToGoodHitsMap, orderedMCParticleVector);
 
     LArFormattingHelper::PrintHeader("MC : Reconstructable primary cosmic-rays");
     LArMonitoringHelper::PrintMCParticleTable(crMCParticlesToGoodHitsMap, orderedMCParticleVector);
 
     LArFormattingHelper::PrintHeader("Reco : Primary cosmic-ray candidates");
     std::cout << "Columns with headers [n] are the number of shared hits between the Pfo and the target MCParticle with ID n." << std::endl;
 
     PfoVector orderedPfoVector;
     LArMonitoringHelper::GetOrderedPfoVector(pfoToReconstructable2DHitsMap, orderedPfoVector);
     this->PrintPfoTable(orderedPfoVector, pfoToReconstructable2DHitsMap, pfoPurityMap, pfoSignificanceMap, pfoClassificationMap, ambiguousPfos);
 }

LArFormattingHelper::Color lar_content::CosmicRayTaggingMonitoringTool::GetClassificationColor ( const Classification & classification ) const

private

Returns a unique color for each possible Pfo classification.

Definition at line 276 of file CosmicRayTaggingMonitoringTool.cc.

 {
     switch (classification)
     {
         case TARGET:
             return LArFormattingHelper::LIGHT_GREEN;
         case CR_MUON:
             return LArFormattingHelper::LIGHT_RED;
         case CR_OTHER:
             return LArFormattingHelper::LIGHT_YELLOW;
         case FRAGMENTED:
             return LArFormattingHelper::LIGHT_BLUE;
         case ABSORBED:
             return LArFormattingHelper::LIGHT_MAGENTA;
         case MIXED:
             return LArFormattingHelper::LIGHT_CYAN;
         default:
             return LArFormattingHelper::LIGHT_GRAY;
     }
 }

std::string lar_content::CosmicRayTaggingMonitoringTool::GetClassificationName ( const Classification & classification ) const

private

Returns a string for each classification.

Definition at line 299 of file CosmicRayTaggingMonitoringTool.cc.

 {
     switch (classification)
     {
         case TARGET:
             return "TARGET";
         case CR_MUON:
             return "CR_MUON";
         case CR_OTHER:
             return "CR_OTHER";
         case FRAGMENTED:
             return "FRAGMENTED";
         case ABSORBED:
             return "ABSORBED";
         case MIXED:
             return "MIXED";
         case SPARSE:
             return "SPARSE";
         default:
             return "UNCLASSIFIED";
     }
 }

bool lar_content::CosmicRayTaggingMonitoringTool::IsMainMCParticleMuon ( const pandora::ParticleFlowObject *const pPfo ) const

private

Returns true if the main MCParticle of the supplied Pfo is a muon.

Definition at line 162 of file CosmicRayTaggingMonitoringTool.cc.

 {
     bool isMuon(false);
     try
     {
         isMuon = false; // TODO Local treatment is being developed, specific to this tool (std::abs(LArMCParticleHelper::GetMainMCParticle(pPfo)->GetParticleId()) == MU_MINUS);
     }
     catch (const StatusCodeException &)
     {
     }
 
     return isMuon;
 }

void lar_content::CosmicRayTaggingMonitoringTool::PrintPfoTable	(	const pandora::PfoVector &	orderedPfoVector,
		const LArMCParticleHelper::PfoContributionMap &	pfoToReconstructable2DHitsMap,
		const PfoToFloatMap &	pfoPurityMap,
		const PfoToFloatMap &	pfoSignificanceMap,
		const PfoClassificationMap &	pfoClassificationMap,
		const pandora::PfoList &	ambiguousPfos
	)		const

private

Prints a table detailing all input Pfos and their classifications.

Parameters

orderedPfoVector	input vector of Pfos in print order
pfoToReconstructable2DHitsMap	input mapping from Pfos to their reconstructable 2D hits
pfoPurityMap	input mapping from Pfos to their purity
pfoSignificanceMap	input mapping from Pfos to their significance
pfoClassificationMap	input mapping from Pfos to their classification
ambiguousPfos	input list of ambiguous Pfos as (not) tagged by a previous CR tagging module

Definition at line 209 of file CosmicRayTaggingMonitoringTool.cc.

 {
     if (orderedPfoVector.empty())
     {
         std::cout << "No Pfos supplied." << std::endl;
         return;
     }
 
     LArFormattingHelper::Table table(
         {"ID", "PID", "", "nHits", "U", "V", "W", "", "nGoodHits", "U", "V", "W", "", "Purity", "Significance", "Classification", "", "Tagged?"});
 
     for (unsigned int id = 0; id < orderedPfoVector.size(); ++id)
     {
         const ParticleFlowObject *const pPfo(orderedPfoVector.at(id));
 
         LArMCParticleHelper::PfoContributionMap::const_iterator it = pfoToReconstructable2DHitsMap.find(pPfo);
         if (pfoToReconstructable2DHitsMap.end() == it)
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         if (pfoPurityMap.end() == pfoPurityMap.find(pPfo))
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         if (pfoSignificanceMap.end() == pfoSignificanceMap.find(pPfo))
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         if (pfoClassificationMap.end() == pfoClassificationMap.find(pPfo))
             throw StatusCodeException(STATUS_CODE_NOT_FOUND);
 
         table.AddElement(id);
         table.AddElement(pPfo->GetParticleId());
 
         CaloHitList all2DCaloHits;
         LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_U, all2DCaloHits);
         LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_V, all2DCaloHits);
         LArPfoHelper::GetCaloHits(pPfo, TPC_VIEW_W, all2DCaloHits);
 
         table.AddElement(all2DCaloHits.size());
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, all2DCaloHits));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, all2DCaloHits));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, all2DCaloHits));
 
         table.AddElement(it->second.size());
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, it->second));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, it->second));
         table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, it->second));
 
         table.AddElement(pfoPurityMap.at(pPfo));
         table.AddElement(pfoSignificanceMap.at(pPfo));
 
         const Classification classification(pfoClassificationMap.at(pPfo));
         table.AddElement(this->GetClassificationName(classification), LArFormattingHelper::INVERTED, this->GetClassificationColor(classification));
 
         const bool isTagged(std::find(ambiguousPfos.begin(), ambiguousPfos.end(), pPfo) == ambiguousPfos.end());
         const bool isGoodTag(isTagged && (classification == CR_MUON || classification == CR_OTHER));
         const bool isBadTag(isTagged && (classification == TARGET));
         const LArFormattingHelper::Color tagColor(
             isGoodTag ? LArFormattingHelper::LIGHT_GREEN : (isBadTag ? LArFormattingHelper::LIGHT_RED : LArFormattingHelper::LIGHT_YELLOW));
         table.AddElement(isTagged ? "yes" : "no", LArFormattingHelper::INVERTED, tagColor);
     }
 
     table.Print();
 }

StatusCode lar_content::CosmicRayTaggingMonitoringTool::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Read settings.

Definition at line 324 of file CosmicRayTaggingMonitoringTool.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitList2D", m_caloHitList2D));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinPrimaryGoodHits", m_parameters.m_minPrimaryGoodHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinHitsForGoodView", m_parameters.m_minHitsForGoodView));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinPrimaryGoodViews", m_parameters.m_minPrimaryGoodViews));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SelectInputHits", m_parameters.m_selectInputHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxPhotonPropagation", m_parameters.m_maxPhotonPropagation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinHitSharingFraction", m_parameters.m_minHitSharingFraction));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinHitsToConsiderTagging", m_minHitsToConsiderTagging));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinPurity", m_minPurity));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinImpurity", m_minImpurity));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinSignificance", m_minSignificance));
 
     return STATUS_CODE_SUCCESS;
 }