#include "CosmicRayTaggingTool.h"

Inheritance diagram for lar_content::CosmicRayTaggingTool:

Classes
class	CRCandidate
	Class to encapsulate the logic required determine if a Pfo should or shouldn't be tagged as a cosmic ray. More...

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

pandora::StatusCode	Initialize ()

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
typedef std::list< CRCandidate >	CRCandidateList

typedef std::unordered_map< const pandora::ParticleFlowObject *, pandora::PfoList >	PfoToPfoListMap

typedef std::unordered_map< const pandora::ParticleFlowObject *, unsigned int >	PfoToSliceIdMap

typedef std::unordered_map< const pandora::ParticleFlowObject *, bool >	PfoToBoolMap

typedef std::set< unsigned int >	UIntSet

typedef std::unordered_map< int, bool >	IntBoolMap

typedef std::pair< const ThreeDSlidingFitResult, const ThreeDSlidingFitResult >	SlidingFitPair

typedef std::unordered_map< const pandora::ParticleFlowObject *, SlidingFitPair >	PfoToSlidingFitsMap

typedef std::vector< pandora::PfoList >	SliceList

Private Member Functions
bool	GetValid3DCluster (const pandora::ParticleFlowObject const pPfo, const pandora::Cluster &pCluster3D) const
	Get the 3D calo hit cluster associated with a given Pfo, and check if it has sufficient hits. More...

void	GetPfoAssociations (const pandora::PfoList &parentCosmicRayPfos, PfoToPfoListMap &pfoAssociationMap) const
	Get mapping between Pfos that are associated with it other by pointing. More...

bool	CheckAssociation (const pandora::CartesianVector &endPoint1, const pandora::CartesianVector &endDir1, const pandora::CartesianVector &endPoint2, const pandora::CartesianVector &endDir2) const
	Check whethe two Pfo endpoints are associated by distance of closest approach. More...

void	SliceEvent (const pandora::PfoList &parentCosmicRayPfos, const PfoToPfoListMap &pfoAssociationMap, PfoToSliceIdMap &pfoToSliceIdMap) const
	Break the event up into slices of associated Pfos. More...

void	FillSlice (const pandora::ParticleFlowObject *const pPfo, const PfoToPfoListMap &pfoAssociationMap, pandora::PfoList &slice) const
	Fill a slice iteratively using Pfo associations. More...

void	GetCRCandidates (const pandora::PfoList &parentCosmicRayPfos, const PfoToSliceIdMap &pfoToSliceIdMap, CRCandidateList &candidates) const
	Make a list of CRCandidates. More...

void	CheckIfInTime (const CRCandidateList &candidates, PfoToBoolMap &pfoToInTimeMap) const
	Check if each candidate is "in time". More...

void	CheckIfContained (const CRCandidateList &candidates, PfoToBoolMap &pfoToIsContainedMap) const
	Check if each candidate is "contained" (contained = no associations to Y or Z detector faces, but the Pfo could still enter or exit by and X-face) More...

void	CheckIfTopToBottom (const CRCandidateList &candidates, PfoToBoolMap &pfoToIsTopToBottomMap) const
	Check if each candidate is "top to bottom". More...

void	GetNeutrinoSlices (const CRCandidateList &candidates, const PfoToBoolMap &pfoToInTimeMap, const PfoToBoolMap &pfoToIsContainedMap, UIntSet &neutrinoSliceSet) const
	Get the slice indices which contain a likely neutrino Pfo. More...

void	TagCRMuons (const CRCandidateList &candidates, const PfoToBoolMap &pfoToInTimeMap, const PfoToBoolMap &pfoToIsTopToBottomMap, const UIntSet &neutrinoSliceSet, PfoToBoolMap &pfoToIsLikelyCRMuonMap) const
	Tag Pfos which are likely to be a CR muon. More...

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

Private Attributes
std::string	m_cutMode
	Choose a set of cuts using a keyword - "cautious" = remove as few neutrinos as possible "nominal" = optimised to maximise CR removal whilst preserving neutrinos "aggressive" = remove CR muons and allow more neutrinos to be tagged. More...

float	m_angularUncertainty
	The uncertainty in degrees for the angle of a Pfo. More...

float	m_positionalUncertainty
	The uncertainty in cm for the position of Pfo endpoint in 3D. More...

float	m_maxAssociationDist
	The maximum distance from endpoint to point of closest approach, typically a multiple of LAr radiation length. More...

unsigned int	m_minimumHits
	The minimum number of hits for a Pfo to be considered. More...

float	m_inTimeMargin
	The maximum distance outside of the physical detector volume that a Pfo may be to still be considered in time. More...

float	m_inTimeMaxX0
	The maximum pfo x0 (determined from shifted vertex) to allow pfo to still be considered in time. More...

float	m_marginY
	The minimum distance from a detector Y-face for a Pfo to be associated. More...

float	m_marginZ
	The minimum distance from a detector Z-face for a Pfo to be associated. More...

float	m_maxNeutrinoCosTheta
	The maximum cos(theta) that a Pfo can have to be classified as a likely neutrino. More...

float	m_minCosmicCosTheta
	The minimum cos(theta) that a Pfo can have to be classified as a likely CR muon. More...

float	m_maxCosmicCurvature
	The maximum curvature that a Pfo can have to be classified as a likely CR muon. More...

float	m_face_Xa
	Anode X face. More...

float	m_face_Xc
	Cathode X face. More...

float	m_face_Yb
	Bottom Y face. More...

float	m_face_Yt
	Top Y face. More...

float	m_face_Zu
	Upstream Z face. More...

float	m_face_Zd
	Downstream Z face. More...

Detailed Description

CosmicRayTaggingTool class.

Definition at line 24 of file CosmicRayTaggingTool.h.

Member Typedef Documentation

typedef std::list<CRCandidate> lar_content::CosmicRayTaggingTool::CRCandidateList

private

Definition at line 69 of file CosmicRayTaggingTool.h.

typedef std::unordered_map<int, bool> lar_content::CosmicRayTaggingTool::IntBoolMap

private

Definition at line 160 of file CosmicRayTaggingTool.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, bool> lar_content::CosmicRayTaggingTool::PfoToBoolMap

private

Definition at line 133 of file CosmicRayTaggingTool.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, pandora::PfoList> lar_content::CosmicRayTaggingTool::PfoToPfoListMap

private

Definition at line 81 of file CosmicRayTaggingTool.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, unsigned int> lar_content::CosmicRayTaggingTool::PfoToSliceIdMap

private

Definition at line 104 of file CosmicRayTaggingTool.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, SlidingFitPair> lar_content::CosmicRayTaggingTool::PfoToSlidingFitsMap

private

Definition at line 188 of file CosmicRayTaggingTool.h.

typedef std::vector<pandora::PfoList> lar_content::CosmicRayTaggingTool::SliceList

private

Definition at line 189 of file CosmicRayTaggingTool.h.

typedef std::pair<const ThreeDSlidingFitResult, const ThreeDSlidingFitResult> lar_content::CosmicRayTaggingTool::SlidingFitPair

private

Definition at line 187 of file CosmicRayTaggingTool.h.

typedef std::set<unsigned int> lar_content::CosmicRayTaggingTool::UIntSet

private

Definition at line 159 of file CosmicRayTaggingTool.h.

Constructor & Destructor Documentation

lar_content::CosmicRayTaggingTool::CosmicRayTaggingTool ( )

Default constructor.

Definition at line 23 of file CosmicRayTaggingTool.cc.

                                            :
     m_cutMode("nominal"),
     m_angularUncertainty(5.f),
     m_positionalUncertainty(3.f),
     m_maxAssociationDist(3.f * 18.f),
     m_minimumHits(15),
     m_inTimeMargin(5.f),
     m_inTimeMaxX0(1.f),
     m_marginY(20.f),
     m_marginZ(10.f),
     m_maxNeutrinoCosTheta(0.2f),
     m_minCosmicCosTheta(0.6f),
     m_maxCosmicCurvature(0.04f),
     m_face_Xa(0.f),
     m_face_Xc(0.f),
     m_face_Yb(0.f),
     m_face_Yt(0.f),
     m_face_Zu(0.f),
     m_face_Zd(0.f)
 {
 }

Member Function Documentation

bool lar_content::CosmicRayTaggingTool::CheckAssociation	(	const pandora::CartesianVector &	endPoint1,
		const pandora::CartesianVector &	endDir1,
		const pandora::CartesianVector &	endPoint2,
		const pandora::CartesianVector &	endDir2
	)		const

private

Check whethe two Pfo endpoints are associated by distance of closest approach.

Parameters

endPoint1	position vector of an endpoint of Pfo 1
endDir1	direction vector of an endpoint of Pfo 1
endPoint2	position vector of an endpoint of Pfo 2
endDir2	direction vector of an endpoint of Pfos

Returns: whether the Pfos are associated

Definition at line 220 of file CosmicRayTaggingTool.cc.

References d, f, m_angularUncertainty, m_face_Xa, m_face_Xc, m_face_Yb, m_face_Yt, m_face_Zd, m_face_Zu, m_maxAssociationDist, m_positionalUncertainty, and n.

Referenced by GetPfoAssociations().

 {
     // TODO This function needs significant tidying and checks (variable names must be self describing, check deltaTheta, etc.)
     const CartesianVector n(endDir1.GetUnitVector());
     const CartesianVector m(endDir2.GetUnitVector());
     const CartesianVector a(endPoint2 - endPoint1);
     const float b(n.GetDotProduct(m));
 
     // Parallel lines never meet
     if (std::fabs(b - 1.f) < std::numeric_limits<float>::epsilon())
         return false;
 
     // Distance from endPoint1 along endDir1 to the point of closest approach
     const float lambda((n - m * b).GetDotProduct(a) / (1.f - b * b));
 
     // Distance from endPoint2 along endDir2 to the point of closest approach
     const float mu((n * b - m).GetDotProduct(a) / (1.f - b * b));
 
     // Calculate the maximum "vertex uncertainty"
     const float deltaTheta(m_angularUncertainty * M_PI / 180.f);
     const float maxVertexUncertainty(m_maxAssociationDist * std::sin(deltaTheta) + m_positionalUncertainty);
 
     // Ensure that the distances to the point of closest approch are within the limits
     if ((lambda < -maxVertexUncertainty) || (mu < -maxVertexUncertainty) || (lambda > m_maxAssociationDist + maxVertexUncertainty) ||
         (mu > m_maxAssociationDist + maxVertexUncertainty))
     {
         return false;
     }
 
     // Ensure point of closest approach is within detector
     const CartesianVector impactPosition((endPoint1 + n * lambda + endPoint2 + m * mu) * 0.5f);
 
     if ((impactPosition.GetX() < m_face_Xa - maxVertexUncertainty) || (impactPosition.GetX() > m_face_Xc + maxVertexUncertainty) ||
         (impactPosition.GetY() < m_face_Yb - maxVertexUncertainty) || (impactPosition.GetY() > m_face_Yt + maxVertexUncertainty) ||
         (impactPosition.GetZ() < m_face_Zu - maxVertexUncertainty) || (impactPosition.GetZ() > m_face_Zd + maxVertexUncertainty))
     {
         return false;
     }
 
     // Compare distance of closest approach and max uncertainty in impact parameter
     const float maxImpactDist(std::sin(deltaTheta) * (std::fabs(mu) + std::fabs(lambda)) + m_positionalUncertainty);
     const CartesianVector d(a - n * lambda + m * mu);
 
     return (d.GetMagnitude() < maxImpactDist);
 }

void lar_content::CosmicRayTaggingTool::CheckIfContained	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToIsContainedMap
	)		const

private

Check if each candidate is "contained" (contained = no associations to Y or Z detector faces, but the Pfo could still enter or exit by and X-face)

Parameters

candidates	input list of candidates
pfoToIsContainedMap	output mapping between candidates Pfos and if they are contained

Definition at line 430 of file CosmicRayTaggingTool.cc.

References m_face_Yb, m_face_Yt, m_face_Zd, m_face_Zu, m_marginY, and m_marginZ.

Referenced by FindAmbiguousPfos().

 {
     for (const CRCandidate &candidate : candidates)
     {
         const float upperY(
             (candidate.m_endPoint1.GetY() > candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetY() : candidate.m_endPoint2.GetY());
         const float lowerY(
             (candidate.m_endPoint1.GetY() < candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetY() : candidate.m_endPoint2.GetY());
 
         const float zAtUpperY(
             (candidate.m_endPoint1.GetY() > candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetZ() : candidate.m_endPoint2.GetZ());
         const float zAtLowerY(
             (candidate.m_endPoint1.GetY() < candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetZ() : candidate.m_endPoint2.GetZ());
 
         const bool isContained((upperY < m_face_Yt - m_marginY) && (upperY > m_face_Yb + m_marginY) && (lowerY < m_face_Yt - m_marginY) &&
             (lowerY > m_face_Yb + m_marginY) && (zAtUpperY < m_face_Zd - m_marginZ) && (zAtUpperY > m_face_Zu + m_marginZ) &&
             (zAtLowerY < m_face_Zd - m_marginZ) && (zAtLowerY > m_face_Zu + m_marginZ));
 
         if (!pfoToIsContainedMap.insert(PfoToBoolMap::value_type(candidate.m_pPfo, isContained)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
     }
 }

void lar_content::CosmicRayTaggingTool::CheckIfInTime	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToInTimeMap
	)		const

private

Check if each candidate is "in time".

Parameters

candidates	input list of candidates
pfoToInTimeMap	output mapping between candidates Pfos and if they are in time

Definition at line 339 of file CosmicRayTaggingTool.cc.

References lar_content::LArPfoHelper::GetCaloHits(), lar_content::LArCaloHit::GetLArTPCVolumeId(), lar_content::LArPfoHelper::GetVertex(), m_face_Xa, m_face_Xc, m_inTimeMargin, and m_inTimeMaxX0.

Referenced by FindAmbiguousPfos().

 {
     const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
 
     for (const CRCandidate &candidate : candidates)
     {
         // Cosmic-ray muons extending outside of (single) physical volume if given t0 is that of the beam particle
         float minX(std::numeric_limits<float>::max()), maxX(-std::numeric_limits<float>::max());
 
         if (candidate.m_canFit)
         {
             minX = ((candidate.m_endPoint1.GetX() < candidate.m_endPoint2.GetX()) ? candidate.m_endPoint1.GetX() : candidate.m_endPoint2.GetX());
             maxX = ((candidate.m_endPoint1.GetX() > candidate.m_endPoint2.GetX()) ? candidate.m_endPoint1.GetX() : candidate.m_endPoint2.GetX());
         }
         else
         {
             // Handle any particles with small numbers of 3D hits, for which no 3D sliding fit information is available
             for (const Cluster *const pCluster : candidate.m_pPfo->GetClusterList())
             {
                 float clusterMinX(std::numeric_limits<float>::max()), clusterMaxX(-std::numeric_limits<float>::max());
                 pCluster->GetClusterSpanX(clusterMinX, clusterMaxX);
                 minX = std::min(clusterMinX, minX);
                 maxX = std::max(clusterMaxX, maxX);
             }
         }
 
         bool isInTime((minX > m_face_Xa - m_inTimeMargin) && (maxX < m_face_Xc + m_inTimeMargin));
 
         // Cosmic-ray muons that have been shifted and stitched across mid plane between volumes
         if (isInTime)
         {
             try
             {
                 if (std::fabs(LArPfoHelper::GetVertex(candidate.m_pPfo)->GetX0()) > m_inTimeMaxX0)
                     isInTime = false;
             }
             catch (const StatusCodeException &)
             {
             }
         }
 
         // Cosmic-ray muons extending outside of (any individual) physical volume if given t0 is that of the beam particle
         if (isInTime)
         {
             CaloHitList caloHitList;
             LArPfoHelper::GetCaloHits(candidate.m_pPfo, TPC_VIEW_U, caloHitList);
             LArPfoHelper::GetCaloHits(candidate.m_pPfo, TPC_VIEW_V, caloHitList);
             LArPfoHelper::GetCaloHits(candidate.m_pPfo, TPC_VIEW_W, caloHitList);
 
             bool isFirstHit(true);
             bool isInSingleVolume(true);
             unsigned int volumeId(std::numeric_limits<unsigned int>::max());
 
             for (const CaloHit *const pCaloHit : caloHitList)
             {
                 const LArCaloHit *const pLArCaloHit(dynamic_cast<const LArCaloHit *>(pCaloHit));
 
                 if (!pLArCaloHit)
                     continue;
 
                 if (isFirstHit)
                 {
                     isFirstHit = false;
                     volumeId = pLArCaloHit->GetLArTPCVolumeId();
                 }
                 else if (volumeId != pLArCaloHit->GetLArTPCVolumeId())
                 {
                     isInSingleVolume = false;
                     break;
                 }
             }
 
             LArTPCMap::const_iterator tpcIter(larTPCMap.find(volumeId));
 
             if (isInSingleVolume && (larTPCMap.end() != tpcIter))
             {
                 const float thisFaceXLow(tpcIter->second->GetCenterX() - 0.5f * tpcIter->second->GetWidthX());
                 const float thisFaceXHigh(tpcIter->second->GetCenterX() + 0.5f * tpcIter->second->GetWidthX());
 
                 if (!((minX > thisFaceXLow - m_inTimeMargin) && (maxX < thisFaceXHigh + m_inTimeMargin)))
                     isInTime = false;
             }
         }
 
         if (!pfoToInTimeMap.insert(PfoToBoolMap::value_type(candidate.m_pPfo, isInTime)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
     }
 }

void lar_content::CosmicRayTaggingTool::CheckIfTopToBottom	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToIsTopToBottomMap
	)		const

private

Check if each candidate is "top to bottom".

Parameters

candidates	input list of candidates
pfoToIsTopToBottomMap	output mapping between candidates Pfos and if they are top to bottom

Definition at line 455 of file CosmicRayTaggingTool.cc.

References m_face_Yb, m_face_Yt, and m_marginY.

Referenced by FindAmbiguousPfos().

 {
     for (const CRCandidate &candidate : candidates)
     {
         const float upperY(
             (candidate.m_endPoint1.GetY() > candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetY() : candidate.m_endPoint2.GetY());
         const float lowerY(
             (candidate.m_endPoint1.GetY() < candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetY() : candidate.m_endPoint2.GetY());
 
         const bool isTopToBottom((upperY > m_face_Yt - m_marginY) && (lowerY < m_face_Yb + m_marginY));
 
         if (!pfoToIsTopToBottomMap.insert(PfoToBoolMap::value_type(candidate.m_pPfo, isTopToBottom)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
     }
 }

void lar_content::CosmicRayTaggingTool::FillSlice	(	const pandora::ParticleFlowObject *const	pPfo,
		const PfoToPfoListMap &	pfoAssociationMap,
		pandora::PfoList &	slice
	)		const

private

Fill a slice iteratively using Pfo associations.

Parameters

pPfo	Pfo to add to the slice
pfoAssociationMap	mapping between Pfos and other associated Pfos
slice	the slice to add Pfos to

Definition at line 308 of file CosmicRayTaggingTool.cc.

Referenced by SliceEvent().

 {
     if (std::find(slice.begin(), slice.end(), pPfo) != slice.end())
         return;
 
     slice.push_back(pPfo);
 
     PfoToPfoListMap::const_iterator iter(pfoAssociationMap.find(pPfo));
 
     if (pfoAssociationMap.end() != iter)
     {
         for (const ParticleFlowObject *const pAssociatedPfo : iter->second)
             this->FillSlice(pAssociatedPfo, pfoAssociationMap, slice);
     }
 }

void lar_content::CosmicRayTaggingTool::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 74 of file CosmicRayTaggingTool.cc.

References CheckIfContained(), CheckIfInTime(), CheckIfTopToBottom(), GetCRCandidates(), GetNeutrinoSlices(), GetPfoAssociations(), m_face_Xa, m_face_Xc, m_face_Yb, m_face_Yt, m_face_Zd, m_face_Zu, SliceEvent(), and TagCRMuons().

 {
     if (this->GetPandora().GetSettings()->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     // TODO First time only, TODO Refactor with master algorithm
     const LArTPCMap &larTPCMap(this->GetPandora().GetGeometry()->GetLArTPCMap());
     const LArTPC *const pFirstLArTPC(larTPCMap.begin()->second);
 
     float parentMinX(pFirstLArTPC->GetCenterX() - 0.5f * pFirstLArTPC->GetWidthX());
     float parentMaxX(pFirstLArTPC->GetCenterX() + 0.5f * pFirstLArTPC->GetWidthX());
     float parentMinY(pFirstLArTPC->GetCenterY() - 0.5f * pFirstLArTPC->GetWidthY());
     float parentMaxY(pFirstLArTPC->GetCenterY() + 0.5f * pFirstLArTPC->GetWidthY());
     float parentMinZ(pFirstLArTPC->GetCenterZ() - 0.5f * pFirstLArTPC->GetWidthZ());
     float parentMaxZ(pFirstLArTPC->GetCenterZ() + 0.5f * pFirstLArTPC->GetWidthZ());
 
     for (const LArTPCMap::value_type &mapEntry : larTPCMap)
     {
         const LArTPC *const pLArTPC(mapEntry.second);
         parentMinX = std::min(parentMinX, pLArTPC->GetCenterX() - 0.5f * pLArTPC->GetWidthX());
         parentMaxX = std::max(parentMaxX, pLArTPC->GetCenterX() + 0.5f * pLArTPC->GetWidthX());
         parentMinY = std::min(parentMinY, pLArTPC->GetCenterY() - 0.5f * pLArTPC->GetWidthY());
         parentMaxY = std::max(parentMaxY, pLArTPC->GetCenterY() + 0.5f * pLArTPC->GetWidthY());
         parentMinZ = std::min(parentMinZ, pLArTPC->GetCenterZ() - 0.5f * pLArTPC->GetWidthZ());
         parentMaxZ = std::max(parentMaxZ, pLArTPC->GetCenterZ() + 0.5f * pLArTPC->GetWidthZ());
     }
 
     m_face_Xa = parentMinX;
     m_face_Xc = parentMaxX;
     m_face_Yb = parentMinY;
     m_face_Yt = parentMaxY;
     m_face_Zu = parentMinZ;
     m_face_Zd = parentMaxZ;
 
     PfoToPfoListMap pfoAssociationMap;
     this->GetPfoAssociations(parentCosmicRayPfos, pfoAssociationMap);
 
     PfoToSliceIdMap pfoToSliceIdMap;
     this->SliceEvent(parentCosmicRayPfos, pfoAssociationMap, pfoToSliceIdMap);
 
     CRCandidateList candidates;
     this->GetCRCandidates(parentCosmicRayPfos, pfoToSliceIdMap, candidates);
 
     PfoToBoolMap pfoToInTimeMap;
     this->CheckIfInTime(candidates, pfoToInTimeMap);
 
     PfoToBoolMap pfoToIsContainedMap;
     this->CheckIfContained(candidates, pfoToIsContainedMap);
 
     PfoToBoolMap pfoToIsTopToBottomMap;
     this->CheckIfTopToBottom(candidates, pfoToIsTopToBottomMap);
 
     UIntSet neutrinoSliceSet;
     this->GetNeutrinoSlices(candidates, pfoToInTimeMap, pfoToIsContainedMap, neutrinoSliceSet);
 
     PfoToBoolMap pfoToIsLikelyCRMuonMap;
     this->TagCRMuons(candidates, pfoToInTimeMap, pfoToIsTopToBottomMap, neutrinoSliceSet, pfoToIsLikelyCRMuonMap);
 
     for (const ParticleFlowObject *const pPfo : parentCosmicRayPfos)
     {
         if (!pfoToIsLikelyCRMuonMap.at(pPfo))
             ambiguousPfos.push_back(pPfo);
     }
 }

void lar_content::CosmicRayTaggingTool::GetCRCandidates	(	const pandora::PfoList &	parentCosmicRayPfos,
		const PfoToSliceIdMap &	pfoToSliceIdMap,
		CRCandidateList &	candidates
	)		const

private

Make a list of CRCandidates.

Parameters

parentCosmicRayPfos	input list of Pfos
pfoToSliceIdMap	input mapping between Pfos and their slice id
candidates	to receive the output list of CRCandidates

Definition at line 326 of file CosmicRayTaggingTool.cc.

References lar_content::LArPfoHelper::IsFinalState().

Referenced by FindAmbiguousPfos().

 {
     for (const ParticleFlowObject *const pPfo : parentCosmicRayPfos)
     {
         if (!LArPfoHelper::IsFinalState(pPfo))
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
         candidates.push_back(CRCandidate(this->GetPandora(), pPfo, pfoToSliceIdMap.at(pPfo)));
     }
 }

void lar_content::CosmicRayTaggingTool::GetNeutrinoSlices	(	const CRCandidateList &	candidates,
		const PfoToBoolMap &	pfoToInTimeMap,
		const PfoToBoolMap &	pfoToIsContainedMap,
		UIntSet &	neutrinoSliceSet
	)		const

private

Get the slice indices which contain a likely neutrino Pfo.

Parameters

candidates	input list of candidates
pfoToInTimeMap	input map between Pfo and if in time
pfoToIsContainedMap	input map between Pfo and if contained
neutrinoSliceSet	output set of slice indices containing a likely neutrino Pfo

Definition at line 473 of file CosmicRayTaggingTool.cc.

References m_maxNeutrinoCosTheta.

Referenced by FindAmbiguousPfos().

 {
     IntBoolMap sliceIdToIsInTimeMap;
 
     for (const CRCandidate &candidate : candidates)
     {
         if (sliceIdToIsInTimeMap.find(candidate.m_sliceId) == sliceIdToIsInTimeMap.end())
             sliceIdToIsInTimeMap.insert(std::make_pair(candidate.m_sliceId, true));
 
         if (!pfoToInTimeMap.at(candidate.m_pPfo))
             sliceIdToIsInTimeMap.at(candidate.m_sliceId) = false;
     }
 
     for (const CRCandidate &candidate : candidates)
     {
         if (neutrinoSliceSet.count(candidate.m_sliceId))
             continue;
 
         const bool likelyNeutrino(candidate.m_canFit && sliceIdToIsInTimeMap.at(candidate.m_sliceId) &&
             (candidate.m_theta < m_maxNeutrinoCosTheta || pfoToIsContainedMap.at(candidate.m_pPfo)));
 
         if (likelyNeutrino)
             (void)neutrinoSliceSet.insert(candidate.m_sliceId);
     }
 }

void lar_content::CosmicRayTaggingTool::GetPfoAssociations	(	const pandora::PfoList &	parentCosmicRayPfos,
		PfoToPfoListMap &	pfoAssociationMap
	)		const

private

Get mapping between Pfos that are associated with it other by pointing.

Parameters

parentCosmicRayPfos	input list of Pfos
pfoAssociationsMap	to receive the output mapping between associated Pfos

Definition at line 157 of file CosmicRayTaggingTool.cc.

References util::begin(), CheckAssociation(), lar_content::ThreeDSlidingFitResult::GetGlobalMaxLayerDirection(), lar_content::ThreeDSlidingFitResult::GetGlobalMinLayerDirection(), and GetValid3DCluster().

Referenced by FindAmbiguousPfos().

 {
     // ATTN If wire w pitches vary between TPCs, exception will be raised in initialisation of lar pseudolayer plugin
     const LArTPC *const pFirstLArTPC(this->GetPandora().GetGeometry()->GetLArTPCMap().begin()->second);
     const float layerPitch(pFirstLArTPC->GetWirePitchW());
 
     PfoToSlidingFitsMap pfoToSlidingFitsMap;
 
     for (const ParticleFlowObject *const pPfo : parentCosmicRayPfos)
     {
         const pandora::Cluster *pCluster(nullptr);
         if (!this->GetValid3DCluster(pPfo, pCluster) || !pCluster)
             continue;
 
         (void)pfoToSlidingFitsMap.insert(PfoToSlidingFitsMap::value_type(pPfo,
             std::make_pair(ThreeDSlidingFitResult(pCluster, 5, layerPitch), ThreeDSlidingFitResult(pCluster, 100, layerPitch)))); // TODO Configurable
     }
 
     for (const ParticleFlowObject *const pPfo1 : parentCosmicRayPfos)
     {
         PfoToSlidingFitsMap::const_iterator iter1(pfoToSlidingFitsMap.find(pPfo1));
         if (pfoToSlidingFitsMap.end() == iter1)
             continue;
 
         const ThreeDSlidingFitResult &fitPos1(iter1->second.first), &fitDir1(iter1->second.second);
 
         for (const ParticleFlowObject *const pPfo2 : parentCosmicRayPfos)
         {
             if (pPfo1 == pPfo2)
                 continue;
 
             PfoToSlidingFitsMap::const_iterator iter2(pfoToSlidingFitsMap.find(pPfo2));
             if (pfoToSlidingFitsMap.end() == iter2)
                 continue;
 
             const ThreeDSlidingFitResult &fitPos2(iter2->second.first), &fitDir2(iter2->second.second);
 
             // TODO Use existing LArPointingClusters and IsEmission/IsNode logic, for consistency
             if (!(this->CheckAssociation(fitPos1.GetGlobalMinLayerPosition(), fitDir1.GetGlobalMinLayerDirection() * -1.f,
                       fitPos2.GetGlobalMinLayerPosition(), fitDir2.GetGlobalMinLayerDirection() * -1.f) ||
                     this->CheckAssociation(fitPos1.GetGlobalMinLayerPosition(), fitDir1.GetGlobalMinLayerDirection() * -1.f,
                         fitPos2.GetGlobalMaxLayerPosition(), fitDir2.GetGlobalMaxLayerDirection()) ||
                     this->CheckAssociation(fitPos1.GetGlobalMaxLayerPosition(), fitDir1.GetGlobalMaxLayerDirection(),
                         fitPos2.GetGlobalMinLayerPosition(), fitDir2.GetGlobalMinLayerDirection() * -1.f) ||
                     this->CheckAssociation(fitPos1.GetGlobalMaxLayerPosition(), fitDir1.GetGlobalMaxLayerDirection(),
                         fitPos2.GetGlobalMaxLayerPosition(), fitDir2.GetGlobalMaxLayerDirection())))
             {
                 continue;
             }
 
             PfoList &pfoList1(pfoAssociationMap[pPfo1]), &pfoList2(pfoAssociationMap[pPfo2]);
 
             if (pfoList1.end() == std::find(pfoList1.begin(), pfoList1.end(), pPfo2))
                 pfoList1.push_back(pPfo2);
 
             if (pfoList2.end() == std::find(pfoList2.begin(), pfoList2.end(), pPfo1))
                 pfoList2.push_back(pPfo1);
         }
     }
 }

bool lar_content::CosmicRayTaggingTool::GetValid3DCluster	(	const pandora::ParticleFlowObject *const	pPfo,
		const pandora::Cluster *&	pCluster3D
	)		const

private

Get the 3D calo hit cluster associated with a given Pfo, and check if it has sufficient hits.

Parameters

pPfo	input Pfo
pCluster3D	to receive the address of the 3D cluster

Returns: whether the Pfo has sufficient hits?

Definition at line 141 of file CosmicRayTaggingTool.cc.

References lar_content::LArPfoHelper::GetThreeDClusterList(), and m_minimumHits.

Referenced by GetPfoAssociations().

 {
     pCluster3D = nullptr;
     ClusterList clusters3D;
     LArPfoHelper::GetThreeDClusterList(pPfo, clusters3D);
 
     // ATTN Only uses first cluster with hits of type TPC_3D
     if (clusters3D.empty() || (clusters3D.front()->GetNCaloHits() < m_minimumHits))
         return false;
 
     pCluster3D = clusters3D.front();
     return true;
 }

StatusCode lar_content::CosmicRayTaggingTool::Initialize ( )

Definition at line 47 of file CosmicRayTaggingTool.cc.

References m_cutMode, m_maxCosmicCurvature, and m_minCosmicCosTheta.

 {
     if ("nominal" == m_cutMode)
     {
         // Nominal values set in constructor
     }
     else if ("cautious" == m_cutMode)
     {
         m_minCosmicCosTheta = std::numeric_limits<double>::max();
         m_maxCosmicCurvature = -std::numeric_limits<double>::max();
     }
     else if ("aggressive" == m_cutMode)
     {
         m_minCosmicCosTheta = 0.6f;
         m_maxCosmicCurvature = 0.1f;
     }
     else
     {
         std::cout << "CosmicRayTaggingTool - invalid cut mode " << m_cutMode << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     return STATUS_CODE_SUCCESS;
 }

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

private

Definition at line 581 of file CosmicRayTaggingTool.cc.

References m_angularUncertainty, m_cutMode, m_inTimeMargin, m_inTimeMaxX0, m_marginY, m_marginZ, m_maxAssociationDist, m_maxCosmicCurvature, m_maxNeutrinoCosTheta, m_minCosmicCosTheta, m_minimumHits, and m_positionalUncertainty.

 {
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CutMode", m_cutMode));
     std::transform(m_cutMode.begin(), m_cutMode.end(), m_cutMode.begin(), ::tolower);
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "AngularUncertainty", m_angularUncertainty));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PositionalUncertainty", m_positionalUncertainty));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxAssociationDist", m_maxAssociationDist));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "HitThreshold", m_minimumHits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "InTimeMargin", m_inTimeMargin));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "InTimeMaxX0", m_inTimeMaxX0));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MarginY", m_marginY));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MarginZ", m_marginZ));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxNeutrinoCosTheta", m_maxNeutrinoCosTheta));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCosmicCosTheta", m_minCosmicCosTheta));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxCosmicCurvature", m_maxCosmicCurvature));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::CosmicRayTaggingTool::SliceEvent	(	const pandora::PfoList &	parentCosmicRayPfos,
		const PfoToPfoListMap &	pfoAssociationMap,
		PfoToSliceIdMap &	pfoToSliceIdMap
	)		const

private

Break the event up into slices of associated Pfos.

Parameters

parentCosmicRayPfos	input list of Pfos
pfoAssociationMap	mapping between Pfos and other associated Pfos
pfoToSliceIdMap	to receive the mapping between Pfos and their slice ID

Definition at line 269 of file CosmicRayTaggingTool.cc.

References FillSlice().

Referenced by FindAmbiguousPfos().

 {
     SliceList sliceList;
 
     for (const ParticleFlowObject *const pPfo : parentCosmicRayPfos)
     {
         bool isAlreadyInSlice(false);
 
         for (const PfoList &slice : sliceList)
         {
             if (std::find(slice.begin(), slice.end(), pPfo) != slice.end())
             {
                 isAlreadyInSlice = true;
                 break;
             }
         }
 
         if (!isAlreadyInSlice)
         {
             sliceList.push_back(PfoList());
             this->FillSlice(pPfo, pfoAssociationMap, sliceList.back());
         }
     }
 
     unsigned int sliceId(0);
     for (const PfoList &slice : sliceList)
     {
         for (const ParticleFlowObject *const pPfo : slice)
         {
             if (!pfoToSliceIdMap.insert(PfoToSliceIdMap::value_type(pPfo, sliceId)).second)
                 throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
         }
 
         ++sliceId;
     }
 }

void lar_content::CosmicRayTaggingTool::TagCRMuons	(	const CRCandidateList &	candidates,
		const PfoToBoolMap &	pfoToInTimeMap,
		const PfoToBoolMap &	pfoToIsTopToBottomMap,
		const UIntSet &	neutrinoSliceSet,
		PfoToBoolMap &	pfoToIsLikelyCRMuonMap
	)		const

private

Tag Pfos which are likely to be a CR muon.

Parameters

candidates	input list of candidates
pfoToInTimeMap	input map between Pfo and if in time
pfoToIsTopToBottomMap	input mapping between candidate Pfos and if they are top to bottom
neutrinoSliceSet	input set of slice indices containing a likely neutrino Pfo
pfoToIsLikelyCRMuonMap	to receive the output mapping between Pfos and a boolean deciding if they are likely a CR muon

Definition at line 502 of file CosmicRayTaggingTool.cc.

References m_maxCosmicCurvature, and m_minCosmicCosTheta.

Referenced by FindAmbiguousPfos().

 {
     for (const CRCandidate &candidate : candidates)
     {
         const bool likelyCRMuon(!neutrinoSliceSet.count(candidate.m_sliceId) &&
             (!pfoToInTimeMap.at(candidate.m_pPfo) ||
                 (candidate.m_canFit &&
                     (pfoToIsTopToBottomMap.at(candidate.m_pPfo) ||
                         ((candidate.m_theta > m_minCosmicCosTheta) && (candidate.m_curvature < m_maxCosmicCurvature))))));
 
         if (!pfoToIsLikelyCRMuonMap.insert(PfoToBoolMap::value_type(candidate.m_pPfo, likelyCRMuon)).second)
             throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
     }
 }

Member Data Documentation

float lar_content::CosmicRayTaggingTool::m_angularUncertainty

private

The uncertainty in degrees for the angle of a Pfo.

Definition at line 198 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and ReadSettings().

std::string lar_content::CosmicRayTaggingTool::m_cutMode

private

Choose a set of cuts using a keyword - "cautious" = remove as few neutrinos as possible "nominal" = optimised to maximise CR removal whilst preserving neutrinos "aggressive" = remove CR muons and allow more neutrinos to be tagged.

Definition at line 196 of file CosmicRayTaggingTool.h.

Referenced by Initialize(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_face_Xa

private

Anode X face.

Definition at line 212 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), CheckIfInTime(), and FindAmbiguousPfos().

float lar_content::CosmicRayTaggingTool::m_face_Xc

private

Cathode X face.

Definition at line 213 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), CheckIfInTime(), and FindAmbiguousPfos().

float lar_content::CosmicRayTaggingTool::m_face_Yb

private

Bottom Y face.

Definition at line 214 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), CheckIfContained(), CheckIfTopToBottom(), and FindAmbiguousPfos().

float lar_content::CosmicRayTaggingTool::m_face_Yt

private

Top Y face.

Definition at line 215 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), CheckIfContained(), CheckIfTopToBottom(), and FindAmbiguousPfos().

float lar_content::CosmicRayTaggingTool::m_face_Zd

private

Downstream Z face.

Definition at line 217 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), CheckIfContained(), and FindAmbiguousPfos().

float lar_content::CosmicRayTaggingTool::m_face_Zu

private

Upstream Z face.

Definition at line 216 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), CheckIfContained(), and FindAmbiguousPfos().

float lar_content::CosmicRayTaggingTool::m_inTimeMargin

private

The maximum distance outside of the physical detector volume that a Pfo may be to still be considered in time.

Definition at line 204 of file CosmicRayTaggingTool.h.

Referenced by CheckIfInTime(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_inTimeMaxX0

private

The maximum pfo x0 (determined from shifted vertex) to allow pfo to still be considered in time.

Definition at line 205 of file CosmicRayTaggingTool.h.

Referenced by CheckIfInTime(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_marginY

private

The minimum distance from a detector Y-face for a Pfo to be associated.

Definition at line 206 of file CosmicRayTaggingTool.h.

Referenced by CheckIfContained(), CheckIfTopToBottom(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_marginZ

private

The minimum distance from a detector Z-face for a Pfo to be associated.

Definition at line 207 of file CosmicRayTaggingTool.h.

Referenced by CheckIfContained(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_maxAssociationDist

private

The maximum distance from endpoint to point of closest approach, typically a multiple of LAr radiation length.

Definition at line 200 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_maxCosmicCurvature

private

The maximum curvature that a Pfo can have to be classified as a likely CR muon.

Definition at line 210 of file CosmicRayTaggingTool.h.

Referenced by Initialize(), ReadSettings(), and TagCRMuons().

float lar_content::CosmicRayTaggingTool::m_maxNeutrinoCosTheta

private

The maximum cos(theta) that a Pfo can have to be classified as a likely neutrino.

Definition at line 208 of file CosmicRayTaggingTool.h.

Referenced by GetNeutrinoSlices(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_minCosmicCosTheta

private

The minimum cos(theta) that a Pfo can have to be classified as a likely CR muon.

Definition at line 209 of file CosmicRayTaggingTool.h.

Referenced by Initialize(), ReadSettings(), and TagCRMuons().

unsigned int lar_content::CosmicRayTaggingTool::m_minimumHits

private

The minimum number of hits for a Pfo to be considered.

Definition at line 202 of file CosmicRayTaggingTool.h.

Referenced by GetValid3DCluster(), and ReadSettings().

float lar_content::CosmicRayTaggingTool::m_positionalUncertainty

private

The uncertainty in cm for the position of Pfo endpoint in 3D.

Definition at line 199 of file CosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and ReadSettings().

The documentation for this class was generated from the following files:

larpandoracontent/v04_08_01/source/larpandoracontent/LArControlFlow/CosmicRayTaggingTool.h
larpandoracontent/v04_08_01/source/larpandoracontent/LArControlFlow/CosmicRayTaggingTool.cc

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation