TestBeamCosmicRayTaggingTool class. More...

#include "TestBeamCosmicRayTaggingTool.h"

Inheritance diagram for lar_content::TestBeamCosmicRayTaggingTool:

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
	TestBeamCosmicRayTaggingTool ()
	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 each 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	CheckIfOutOfTime (const CRCandidateList &candidates, PfoToBoolMap &pfoToIsCosmicRayMap) const
	Check if each candidate is "in time". More...

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

void	CheckIfTopEntering (const CRCandidateList &candidates, PfoToBoolMap &pfoToIsCosmicRayMap) const
	Check if each candidate enters from the top of the detector. More...

void	CheckIfInVetoedTPC (const CRCandidateList &candidates, PfoToBoolMap &pfoToIsCosmicRayMap) const
	Check if each candidate has its highest value in one of the vetoed TPC volumes. More...

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

Private Attributes
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...

bool	m_tagTopEntering
	Whether to tag all top entering particles as cosmic rays. More...

bool	m_tagTopToBottom
	Whether to tag all top-to-bottom particles as cosmic rays. More...

bool	m_tagOutOfTime
	Whether to tag all out-of-time particles as cosmic rays. More...

bool	m_tagInVetoedTPCs
	Whether to tag all particles with their highest position in vetoed TPCs as cosmic rays. More...

std::vector< unsigned int >	m_vetoedTPCs
	List of vetoed TPCs for tagging cosmic rays. 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

TestBeamCosmicRayTaggingTool class.

Definition at line 24 of file TestBeamCosmicRayTaggingTool.h.

Member Typedef Documentation

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

private

Definition at line 76 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 175 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 140 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 88 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 111 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 180 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 181 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 179 of file TestBeamCosmicRayTaggingTool.h.

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

private

Definition at line 174 of file TestBeamCosmicRayTaggingTool.h.

Constructor & Destructor Documentation

lar_content::TestBeamCosmicRayTaggingTool::TestBeamCosmicRayTaggingTool ( )

Default constructor.

Definition at line 23 of file TestBeamCosmicRayTaggingTool.cc.

                                                            :
     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_tagTopEntering(true),
     m_tagTopToBottom(true),
     m_tagOutOfTime(true),
     m_tagInVetoedTPCs(false),
     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::TestBeamCosmicRayTaggingTool::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 207 of file TestBeamCosmicRayTaggingTool.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::TestBeamCosmicRayTaggingTool::CheckIfInVetoedTPC	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToIsCosmicRayMap
	)		const

private

Check if each candidate has its highest value in one of the vetoed TPC volumes.

Parameters

candidates	input list of candidates
pfoToIsCosmicRayMap	output mapping between candidates Pfos and if they are in the vetoed TPCs

Definition at line 454 of file TestBeamCosmicRayTaggingTool.cc.

References lar_content::LArPfoHelper::GetCaloHits(), lar_content::LArCaloHit::GetLArTPCVolumeId(), and m_vetoedTPCs.

Referenced by FindAmbiguousPfos().

 {
     if (m_vetoedTPCs.empty())
         return;
 
     for (const CRCandidate &candidate : candidates)
     {
         // Move on if this candidate has already been tagged
         if (pfoToIsCosmicRayMap.at(candidate.m_pPfo))
             continue;
 
         // We have to go via the hit volume id to get the TPC
         CaloHitList caloHitList3D;
         LArPfoHelper::GetCaloHits(candidate.m_pPfo, TPC_3D, caloHitList3D);
 
         float maxYPosition{-1.f * std::numeric_limits<float>::max()};
         unsigned int maxYTPCId{std::numeric_limits<unsigned int>::max()};
         for (const CaloHit *const pCaloHit : caloHitList3D)
         {
             const float hitYPos(pCaloHit->GetPositionVector().GetY());
             if (maxYPosition < hitYPos)
             {
                 maxYPosition = hitYPos;
                 const LArCaloHit *const pLArCaloHit{reinterpret_cast<LArCaloHit *>(const_cast<void *>(pCaloHit->GetParentAddress()))};
                 const unsigned int maxYDriftVol = pLArCaloHit->GetLArTPCVolumeId();
                 const unsigned int maxYAPA = pLArCaloHit->GetDaughterVolumeId();
                 maxYTPCId = maxYDriftVol + maxYAPA * 4;
             }
         }
         if (std::find(m_vetoedTPCs.begin(), m_vetoedTPCs.end(), maxYTPCId) != m_vetoedTPCs.end())
             pfoToIsCosmicRayMap[candidate.m_pPfo] = true;
     }
 }

void lar_content::TestBeamCosmicRayTaggingTool::CheckIfOutOfTime	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToIsCosmicRayMap
	)		const

private

Check if each candidate is "in time".

Parameters

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

Definition at line 328 of file TestBeamCosmicRayTaggingTool.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)
     {
         // Move on if this candidate has already been tagged
         if (pfoToIsCosmicRayMap.at(candidate.m_pPfo))
             continue;
         // 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;
             }
         }
 
         pfoToIsCosmicRayMap[candidate.m_pPfo] = !isInTime;
     }
 }

void lar_content::TestBeamCosmicRayTaggingTool::CheckIfTopEntering	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToIsCosmicRayMap
	)		const

private

Check if each candidate enters from the top of the detector.

Parameters

candidates	input list of candidates
pfoToIsCosmicRayMap	output mapping between candidates Pfos and if they are top entering

Definition at line 439 of file TestBeamCosmicRayTaggingTool.cc.

References m_face_Yt, and m_marginY.

Referenced by FindAmbiguousPfos().

 {
     for (const CRCandidate &candidate : candidates)
     {
         // Move on if this candidate has already been tagged
         if (pfoToIsCosmicRayMap.at(candidate.m_pPfo))
             continue;
         const float upperY(
             (candidate.m_endPoint1.GetY() > candidate.m_endPoint2.GetY()) ? candidate.m_endPoint1.GetY() : candidate.m_endPoint2.GetY());
         pfoToIsCosmicRayMap[candidate.m_pPfo] = (upperY > m_face_Yt - m_marginY);
     }
 }

void lar_content::TestBeamCosmicRayTaggingTool::CheckIfTopToBottom	(	const CRCandidateList &	candidates,
		PfoToBoolMap &	pfoToIsCosmicRayMap
	)		const

private

Check if each candidate is "top to bottom".

Parameters

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

Definition at line 421 of file TestBeamCosmicRayTaggingTool.cc.

References m_face_Yb, m_face_Yt, and m_marginY.

Referenced by FindAmbiguousPfos().

 {
     for (const CRCandidate &candidate : candidates)
     {
         // Move on if this candidate has already been tagged
         if (pfoToIsCosmicRayMap.at(candidate.m_pPfo))
             continue;
         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());
 
         pfoToIsCosmicRayMap[candidate.m_pPfo] = ((upperY > m_face_Yt - m_marginY) && (lowerY < m_face_Yb + m_marginY));
     }
 }

void lar_content::TestBeamCosmicRayTaggingTool::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 296 of file TestBeamCosmicRayTaggingTool.cc.

Referenced by SliceEvent().

 {
     if (std::find(slice.begin(), slice.end(), pPfo) != slice.end())
         return;
 
     slice.emplace_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::TestBeamCosmicRayTaggingTool::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 53 of file TestBeamCosmicRayTaggingTool.cc.

References CheckIfInVetoedTPC(), CheckIfOutOfTime(), CheckIfTopEntering(), CheckIfTopToBottom(), GetCRCandidates(), GetPfoAssociations(), m_face_Xa, m_face_Xc, m_face_Yb, m_face_Yt, m_face_Zd, m_face_Zu, m_tagInVetoedTPCs, m_tagOutOfTime, m_tagTopEntering, m_tagTopToBottom, and SliceEvent().

 {
     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);
 
     // Create a map that will be used to find all cosmic ray pfos
     PfoToBoolMap pfoToIsCosmicRayMap;
     for (const CRCandidate &candidate : candidates)
     {
         pfoToIsCosmicRayMap[candidate.m_pPfo] = false;
     }
 
     // Tag all particles appearing to enter from the top
     if (m_tagTopEntering)
         this->CheckIfTopEntering(candidates, pfoToIsCosmicRayMap);
 
     // Tag particles going from top to bottom
     if (m_tagTopToBottom)
         this->CheckIfTopToBottom(candidates, pfoToIsCosmicRayMap);
 
     // Tag particles with t0 != 0 or appears outside the detector with t0 = 0
     if (m_tagOutOfTime)
         this->CheckIfOutOfTime(candidates, pfoToIsCosmicRayMap);
 
     // Tag particles with their highest point in a given list of TPCs
     if (m_tagInVetoedTPCs)
         this->CheckIfInVetoedTPC(candidates, pfoToIsCosmicRayMap);
 
     for (const ParticleFlowObject *const pPfo : parentCosmicRayPfos)
     {
         if (!pfoToIsCosmicRayMap.at(pPfo))
             ambiguousPfos.push_back(pPfo);
     }
 }

void lar_content::TestBeamCosmicRayTaggingTool::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 314 of file TestBeamCosmicRayTaggingTool.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.emplace_back(CRCandidate(this->GetPandora(), pPfo, pfoToSliceIdMap.at(pPfo)));
     }
 }

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

private

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

Parameters

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

Definition at line 144 of file TestBeamCosmicRayTaggingTool.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;
 
         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::TestBeamCosmicRayTaggingTool::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 128 of file TestBeamCosmicRayTaggingTool.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::TestBeamCosmicRayTaggingTool::Initialize ( )

Definition at line 46 of file TestBeamCosmicRayTaggingTool.cc.

 {
     return STATUS_CODE_SUCCESS;
 }

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

private

Definition at line 551 of file TestBeamCosmicRayTaggingTool.cc.

References m_angularUncertainty, m_inTimeMargin, m_inTimeMaxX0, m_marginY, m_maxAssociationDist, m_minimumHits, m_positionalUncertainty, m_tagInVetoedTPCs, m_tagOutOfTime, m_tagTopEntering, m_tagTopToBottom, and m_vetoedTPCs.

 {
     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, "TagTopEntering", m_tagTopEntering));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TagTopToBottom", m_tagTopToBottom));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TagOutOfTime", m_tagOutOfTime));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "TagInVetoedTPCs", m_tagInVetoedTPCs));
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(xmlHandle, "VetoedTPCs", m_vetoedTPCs));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::TestBeamCosmicRayTaggingTool::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 256 of file TestBeamCosmicRayTaggingTool.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;
     }
 }

Member Data Documentation

float lar_content::TestBeamCosmicRayTaggingTool::m_angularUncertainty

private

The uncertainty in degrees for the angle of a Pfo.

Definition at line 183 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and ReadSettings().

float lar_content::TestBeamCosmicRayTaggingTool::m_face_Xa

private

Anode X face.

Definition at line 200 of file TestBeamCosmicRayTaggingTool.h.

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

float lar_content::TestBeamCosmicRayTaggingTool::m_face_Xc

private

Cathode X face.

Definition at line 201 of file TestBeamCosmicRayTaggingTool.h.

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

float lar_content::TestBeamCosmicRayTaggingTool::m_face_Yb

private

Bottom Y face.

Definition at line 202 of file TestBeamCosmicRayTaggingTool.h.

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

float lar_content::TestBeamCosmicRayTaggingTool::m_face_Yt

private

Top Y face.

Definition at line 203 of file TestBeamCosmicRayTaggingTool.h.

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

float lar_content::TestBeamCosmicRayTaggingTool::m_face_Zd

private

Downstream Z face.

Definition at line 205 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and FindAmbiguousPfos().

float lar_content::TestBeamCosmicRayTaggingTool::m_face_Zu

private

Upstream Z face.

Definition at line 204 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and FindAmbiguousPfos().

float lar_content::TestBeamCosmicRayTaggingTool::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 189 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckIfOutOfTime(), and ReadSettings().

float lar_content::TestBeamCosmicRayTaggingTool::m_inTimeMaxX0

private

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

Definition at line 190 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckIfOutOfTime(), and ReadSettings().

float lar_content::TestBeamCosmicRayTaggingTool::m_marginY

private

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

Definition at line 191 of file TestBeamCosmicRayTaggingTool.h.

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

float lar_content::TestBeamCosmicRayTaggingTool::m_maxAssociationDist

private

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

Definition at line 185 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and ReadSettings().

unsigned int lar_content::TestBeamCosmicRayTaggingTool::m_minimumHits

private

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

Definition at line 187 of file TestBeamCosmicRayTaggingTool.h.

Referenced by GetValid3DCluster(), and ReadSettings().

float lar_content::TestBeamCosmicRayTaggingTool::m_positionalUncertainty

private

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

Definition at line 184 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckAssociation(), and ReadSettings().

bool lar_content::TestBeamCosmicRayTaggingTool::m_tagInVetoedTPCs

private

Whether to tag all particles with their highest position in vetoed TPCs as cosmic rays.

Definition at line 197 of file TestBeamCosmicRayTaggingTool.h.

Referenced by FindAmbiguousPfos(), and ReadSettings().

bool lar_content::TestBeamCosmicRayTaggingTool::m_tagOutOfTime

private

Whether to tag all out-of-time particles as cosmic rays.

Definition at line 195 of file TestBeamCosmicRayTaggingTool.h.

Referenced by FindAmbiguousPfos(), and ReadSettings().

bool lar_content::TestBeamCosmicRayTaggingTool::m_tagTopEntering

private

Whether to tag all top entering particles as cosmic rays.

Definition at line 193 of file TestBeamCosmicRayTaggingTool.h.

Referenced by FindAmbiguousPfos(), and ReadSettings().

bool lar_content::TestBeamCosmicRayTaggingTool::m_tagTopToBottom

private

Whether to tag all top-to-bottom particles as cosmic rays.

Definition at line 194 of file TestBeamCosmicRayTaggingTool.h.

Referenced by FindAmbiguousPfos(), and ReadSettings().

std::vector<unsigned int> lar_content::TestBeamCosmicRayTaggingTool::m_vetoedTPCs

private

List of vetoed TPCs for tagging cosmic rays.

Definition at line 198 of file TestBeamCosmicRayTaggingTool.h.

Referenced by CheckIfInVetoedTPC(), and ReadSettings().

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

larpandoracontent/v04_14_00/source/larpandoracontent/LArControlFlow/TestBeamCosmicRayTaggingTool.h
larpandoracontent/v04_14_00/source/larpandoracontent/LArControlFlow/TestBeamCosmicRayTaggingTool.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