ConeChargeFeatureTool class for the calculation of charge distribution and conicalness. More...

#include <TrackShowerIdFeatureTool.h>

Inheritance diagram for lar_content::ConeChargeFeatureTool:

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

void	Run (LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pInputPfo)

void	Run (LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName, const pandora::Algorithm const pAlgorithm, const pandora::ParticleFlowObject const pInputPfo)

Public Member Functions inherited from lar_content::MvaFeatureTool< Ts >
	MvaFeatureTool ()=default
	Default constructor. More...

virtual void	Run (MvaTypes::MvaFeatureVector &featureVector, Ts...args)=0
	Run the algorithm tool. More...

virtual void	Run (MvaTypes::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName, Ts...args)

Private Member Functions
pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

void	CalculateChargeDistribution (const pandora::CaloHitList &caloHitList, const pandora::CartesianVector &pfoStart, const pandora::CartesianVector &pfoDir, float &chargeCore, float &chargeHalo, float &chargeCon)
	Calculate charge distribution in relation to the Moeliere radius. More...

float	CalculateConicalness (const pandora::CaloHitList &caloHitList, const pandora::CartesianVector &pfoStart, const pandora::CartesianVector &pfoDir, const float pfoLength)
	Calculate conicalness as a ratio of charge distribution at the end and start of pfo. More...

Private Attributes
unsigned int	m_conMinHits
	Configurable parameters to calculate cone charge variables. More...

float	m_minCharge

float	m_conFracRange

float	m_MoliereRadius

float	m_MoliereRadiusFrac

Additional Inherited Members
Public Types inherited from lar_content::MvaFeatureTool< Ts >
typedef std::vector < MvaFeatureTool< Ts...> * >	FeatureToolVector

typedef std::map< std::string, MvaFeatureTool< Ts...> * >	FeatureToolMap

Detailed Description

ConeChargeFeatureTool class for the calculation of charge distribution and conicalness.

Definition at line 210 of file TrackShowerIdFeatureTool.h.

Constructor & Destructor Documentation

lar_content::ConeChargeFeatureTool::ConeChargeFeatureTool ( )

Default constructor.

Definition at line 397 of file TrackShowerIdFeatureTool.cc.

                                              :
     m_conMinHits(3),
     m_minCharge(0.1f),
     m_conFracRange(0.2f),
     m_MoliereRadius(10.1f),
     m_MoliereRadiusFrac(0.2f)
 {
 }

Member Function Documentation

void lar_content::ConeChargeFeatureTool::CalculateChargeDistribution	(	const pandora::CaloHitList &	caloHitList,
		const pandora::CartesianVector &	pfoStart,
		const pandora::CartesianVector &	pfoDir,
		float &	chargeCore,
		float &	chargeHalo,
		float &	chargeCon
	)

private

Calculate charge distribution in relation to the Moeliere radius.

Parameters

caloHitList,:	the calo hit list of plane w
pfoStart,:	start position of the pfo
pfoDir,:	direction of pfo from the principle vector of pca
chargeCore,:	to receive sum of charge within Moeliete radius * fraction
chargeHalo,:	to receive sum of charge outside of Moeliere radius * fraction
chargeCon,:	to receive weighted sum of total charge

Definition at line 472 of file TrackShowerIdFeatureTool.cc.

 {
     for (const CaloHit *const pCaloHit : caloHitList)
     {
         const float distFromTrackFit(((pCaloHit->GetPositionVector() - pfoStart).GetCrossProduct(pfoDir)).GetMagnitude());
 
         if (distFromTrackFit < m_MoliereRadiusFrac * m_MoliereRadius)
             chargeCore += pCaloHit->GetInputEnergy();
         else
             chargeHalo += pCaloHit->GetInputEnergy();
 
         chargeCon += pCaloHit->GetInputEnergy() / std::max(1.E-2f, distFromTrackFit); /* Set 1.E-2f to prevent division by 0 and to set max histogram bin as 100 */
     }
 }

float lar_content::ConeChargeFeatureTool::CalculateConicalness	(	const pandora::CaloHitList &	caloHitList,
		const pandora::CartesianVector &	pfoStart,
		const pandora::CartesianVector &	pfoDir,
		const float	pfoLength
	)

private

Calculate conicalness as a ratio of charge distribution at the end and start of pfo.

Parameters

caloHitList,:	the calo hit list of plane w
pfoStart,:	start position of the pfo
pfoDir,:	direction of pfo from the principle vector of pca
pfoLength,:	length of the whole pfo return conicalness

Definition at line 490 of file TrackShowerIdFeatureTool.cc.

 {
     float totalChargeStart(0.f), totalChargeEnd(0.f);
     float chargeConStart(0.f), chargeConEnd(0.f);
     unsigned int nHitsConStart(0), nHitsConEnd(0);
 
     for (const CaloHit *const pCaloHit : caloHitList)
     {
         const float distFromTrackFit(((pCaloHit->GetPositionVector() - pfoStart).GetCrossProduct(pfoDir)).GetMagnitude());
         const float hitLength(std::fabs((pCaloHit->GetPositionVector() - pfoStart).GetDotProduct(pfoDir)));
 
         if (hitLength / pfoLength < m_conFracRange)
         {
             chargeConStart += distFromTrackFit * distFromTrackFit * pCaloHit->GetInputEnergy();
             ++nHitsConStart;
             totalChargeStart += pCaloHit->GetInputEnergy();
         }
         else if (1.f - hitLength / pfoLength < m_conFracRange)
         {
             chargeConEnd += distFromTrackFit * distFromTrackFit * pCaloHit->GetInputEnergy();
             ++nHitsConEnd;
             totalChargeEnd += pCaloHit->GetInputEnergy();
         }
     }
 
     float conicalness(1.f);
 
     if (nHitsConStart >= m_conMinHits && nHitsConEnd >= m_conMinHits && totalChargeEnd > m_minCharge &&
         std::sqrt(chargeConStart) > m_minCharge && totalChargeStart > m_minCharge)
         conicalness = (std::sqrt(chargeConEnd / chargeConStart)) / (totalChargeEnd / totalChargeStart);
 
     return conicalness;
 }

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

private

Definition at line 527 of file TrackShowerIdFeatureTool.cc.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConMinHits", m_conMinHits));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCharge", m_minCharge));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConFracRange", m_conFracRange));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MoliereRadius", m_MoliereRadius));
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MoliereRadiusFrac", m_MoliereRadiusFrac));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::ConeChargeFeatureTool::Run	(	LArMvaHelper::MvaFeatureVector &	featureVector,
		const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pInputPfo
	)

Definition at line 408 of file TrackShowerIdFeatureTool.cc.

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     ClusterList clusterListW;
     LArPfoHelper::GetClusters(pInputPfo, TPC_VIEW_W, clusterListW);
 
     LArMvaHelper::MvaFeature haloTotalRatio, concentration, conicalness;
 
     if (!clusterListW.empty())
     {
         CaloHitList clusterCaloHitList;
         clusterListW.front()->GetOrderedCaloHitList().FillCaloHitList(clusterCaloHitList);
 
         const CartesianVector &pfoStart(clusterCaloHitList.front()->GetPositionVector());
         CartesianVector centroid(0.f, 0.f, 0.f);
         LArPcaHelper::EigenVectors eigenVecs;
         LArPcaHelper::EigenValues eigenValues(0.f, 0.f, 0.f);
         LArPcaHelper::RunPca(clusterCaloHitList, centroid, eigenValues, eigenVecs);
 
         float chargeCore(0.f), chargeHalo(0.f), chargeCon(0.f);
         this->CalculateChargeDistribution(clusterCaloHitList, pfoStart, eigenVecs[0], chargeCore, chargeHalo, chargeCon);
         haloTotalRatio = (chargeCore + chargeHalo > std::numeric_limits<float>::epsilon()) ? chargeHalo / (chargeCore + chargeHalo) : -1.f;
         concentration = (chargeCore + chargeHalo > std::numeric_limits<float>::epsilon()) ? chargeCon / (chargeCore + chargeHalo) : -1.f;
         const float pfoLength(std::sqrt(LArPfoHelper::GetThreeDLengthSquared(pInputPfo)));
         conicalness = (pfoLength > std::numeric_limits<float>::epsilon())
                           ? this->CalculateConicalness(clusterCaloHitList, pfoStart, eigenVecs[0], pfoLength)
                           : 1.f;
     }
 
     featureVector.push_back(haloTotalRatio);
     featureVector.push_back(concentration);
     featureVector.push_back(conicalness);
 }

void lar_content::ConeChargeFeatureTool::Run	(	LArMvaHelper::MvaFeatureMap &	featureMap,
		pandora::StringVector &	featureOrder,
		const std::string &	featureToolName,
		const pandora::Algorithm *const	pAlgorithm,
		const pandora::ParticleFlowObject *const	pInputPfo
	)

Member Data Documentation

float lar_content::ConeChargeFeatureTool::m_conFracRange

private

Definition at line 236 of file TrackShowerIdFeatureTool.h.

unsigned int lar_content::ConeChargeFeatureTool::m_conMinHits

private

Configurable parameters to calculate cone charge variables.

Parameters

conMinHits,:	minimum hit requirement at start and end of pfo to calculate conicalness
minCharge,:	minimum charge requirement at start and end of pfo to calculate conicalness
conFracRange,:	conincal fractional range to determine start/end of pfo
MoliereRadius,:	10.1 cm to determine halo/core of pfo
MoliereRadiusFrac,:	fraction of Moliere radius, default = 0.2