lar_content::CosmicRayTaggingTool Class Reference

CosmicRayTaggingTool class. More...

#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 23 of file CosmicRayTaggingTool.h.

Member Typedef Documentation

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

private

Definition at line 68 of file CosmicRayTaggingTool.h.

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

private

Definition at line 159 of file CosmicRayTaggingTool.h.

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

private

Definition at line 132 of file CosmicRayTaggingTool.h.

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

private

Definition at line 80 of file CosmicRayTaggingTool.h.

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

private

Definition at line 103 of file CosmicRayTaggingTool.h.

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

private

Definition at line 187 of file CosmicRayTaggingTool.h.

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

private

Definition at line 188 of file CosmicRayTaggingTool.h.

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

private

Definition at line 186 of file CosmicRayTaggingTool.h.

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

private

Definition at line 158 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.

{
    // 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.

{
    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.

{
    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.

{
    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.

{
    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.

{
    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.

{
    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.

{
    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.

{
    // 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.

{
    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

(

void

)

Definition at line 47 of file CosmicRayTaggingTool.cc.

{
    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.

{
    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.

{
    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.

{
    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 197 of file CosmicRayTaggingTool.h.

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 195 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_face_Xa

private

Anode X face.

Definition at line 211 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_face_Xc

private

Cathode X face.

Definition at line 212 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_face_Yb

private

Bottom Y face.

Definition at line 213 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_face_Yt

private

Top Y face.

Definition at line 214 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_face_Zd

private

Downstream Z face.

Definition at line 216 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_face_Zu

private

Upstream Z face.

Definition at line 215 of file CosmicRayTaggingTool.h.

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 203 of file CosmicRayTaggingTool.h.

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 204 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_marginY

private

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

Definition at line 205 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_marginZ

private

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

Definition at line 206 of file CosmicRayTaggingTool.h.

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 199 of file CosmicRayTaggingTool.h.

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 209 of file CosmicRayTaggingTool.h.

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 207 of file CosmicRayTaggingTool.h.

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 208 of file CosmicRayTaggingTool.h.

unsigned int lar_content::CosmicRayTaggingTool::m_minimumHits

private

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

Definition at line 201 of file CosmicRayTaggingTool.h.

float lar_content::CosmicRayTaggingTool::m_positionalUncertainty

private

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

Definition at line 198 of file CosmicRayTaggingTool.h.

---

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

• larpandoracontent/larpandoracontent/LArControlFlow/CosmicRayTaggingTool.h
• larpandoracontent/larpandoracontent/LArControlFlow/CosmicRayTaggingTool.cc