lar_content::LArMCParticleHelper Class Reference

LArMCParticleHelper class. More...

#include <LArMCParticleHelper.h>

Classes
class	PrimaryParameters
	PrimaryParameters class. More...

Public Types
typedef std::unordered_map < const pandora::MCParticle *, const pandora::MCParticle * >	MCRelationMap
typedef std::unordered_map < const pandora::MCParticle *, int >	MCParticleIntMap
typedef std::unordered_map < const pandora::MCParticle *, const pandora::ParticleFlowObject * >	MCToPfoMap
typedef std::unordered_map < const pandora::CaloHit *, const pandora::MCParticle * >	CaloHitToMCMap
typedef std::unordered_map < const pandora::CaloHit *, const pandora::ParticleFlowObject * >	CaloHitToPfoMap
typedef std::unordered_map < const pandora::MCParticle *, pandora::CaloHitList >	MCContributionMap
typedef std::vector < MCContributionMap >	MCContributionMapVector
typedef std::unordered_map < const pandora::Cluster *, pandora::CaloHitList >	ClusterContributionMap
typedef std::unordered_map < const pandora::ParticleFlowObject *, pandora::CaloHitList >	PfoContributionMap
typedef std::unordered_map < const pandora::MCParticle *, PfoContributionMap >	MCToPfoMatchingMap
typedef std::pair< const pandora::MCParticle *, pandora::CaloHitList >	MCParticleCaloHitListPair
typedef std::pair< const pandora::ParticleFlowObject *, pandora::CaloHitList >	PfoCaloHitListPair
typedef std::pair< const pandora::Cluster *, pandora::CaloHitList >	ClusterCaloHitListPair
typedef std::vector < MCParticleCaloHitListPair >	MCParticleToSharedHitsVector
typedef std::vector < PfoCaloHitListPair >	PfoToSharedHitsVector
typedef std::map< const pandora::ParticleFlowObject *, MCParticleToSharedHitsVector >	PfoToMCParticleHitSharingMap
typedef std::map< const pandora::MCParticle *, PfoToSharedHitsVector >	MCParticleToPfoHitSharingMap

Static Public Member Functions
static bool	DoesPrimaryMeetCriteria (const pandora::MCParticle *const pMCParticle, std::function< bool(const pandora::MCParticle *const)> fCriteria)
	Returns true if passed particle whose primary meets the passed criteria. More...
static bool	DoesLeadingMeetCriteria (const pandora::MCParticle *const pMCParticle, std::function< bool(const pandora::MCParticle *const)> fCriteria)
	Returns true if passed particle whose leading meets the passed criteria. More...
static bool	IsBeamNeutrinoFinalState (const pandora::MCParticle *const pMCParticle)
	Returns true if passed a primary neutrino final state MCParticle. More...
static bool	IsTriggeredBeamParticle (const pandora::MCParticle *const pMCParticle)
	Returns true if passed a primary triggered beam MCParticle. More...
static bool	IsBeamParticle (const pandora::MCParticle *const pMCParticle)
	Returns true if passed a primary beam MCParticle. More...
static bool	IsLeadingBeamParticle (const pandora::MCParticle *const pMCParticle)
	Returns true if passed a leading beam MCParticle. More...
static bool	IsCosmicRay (const pandora::MCParticle *const pMCParticle)
	Return true if passed a primary cosmic ray MCParticle. More...
static unsigned int	GetNuanceCode (const pandora::MCParticle *const pMCParticle)
	Get the nuance code of an MCParticle. More...
static bool	IsNeutrino (const pandora::MCParticle *const pMCParticle)
	Whether a mc particle is a neutrino or antineutrino. More...
static bool	IsPrimary (const pandora::MCParticle *const pMCParticle)
	Whether a provided mc particle matches the implemented definition of being primary. More...
static bool	IsLeading (const pandora::MCParticle *const pMCParticle)
	Whether a provided mc particle matches the implemented definition of being leading. More...
static int	GetHierarchyTier (const pandora::MCParticle *const pMCParticle)
	Determine the position in the hierarchy for the MCParticle. More...
static bool	IsVisible (const pandora::MCParticle *const pMCParticle)
	Whether a mc particle is visible (i.e. long-lived charged particle) More...
static void	GetTrueNeutrinos (const pandora::MCParticleList *const pMCParticleList, pandora::MCParticleVector &trueNeutrinos)
	Get neutrino MC particles from an input MC particle list. More...
static void	GetTrueTestBeamParticles (const pandora::MCParticleList *const pMCParticleList, pandora::MCParticleVector &trueTestBeamParticles)
	Get triggered test beam MC particles from an input MC particle list. More...
static const pandora::MCParticle *	GetPrimaryMCParticle (const pandora::MCParticle *const pMCParticle)
	Get the primary parent mc particle. More...
static const pandora::MCParticle *	GetLeadingMCParticle (const pandora::MCParticle *const pMCParticle, const int hierarchyTierLimit=1)
	Get the leading particle in the hierarchy, for use at ProtoDUNE. More...
static void	GetPrimaryMCParticleList (const pandora::MCParticleList *const pMCParticleList, pandora::MCParticleVector &mcPrimaryVector)
	Get vector of primary MC particles from an input list of MC particles. More...
static void	GetLeadingMCParticleList (const pandora::MCParticleList *const pMCParticleList, pandora::MCParticleVector &mcLeadingVector)
	Get vector of leading MC particles from an input list of MC particles. More...
static const pandora::MCParticle *	GetParentMCParticle (const pandora::MCParticle *const pMCParticle)
	Get the parent mc particle. More...
static void	GetAllDescendentMCParticles (const pandora::MCParticle *const pMCParticle, pandora::MCParticleList &descendentMCParticleList)
	Get all descendent mc particles. More...
static void	GetAllDescendentMCParticles (const pandora::MCParticle *const pMCParticle, pandora::MCParticleList &descendentTrackParticles, pandora::MCParticleList &leadingShowerParticles, pandora::MCParticleList &leadingNeutrons)
	Get all descendent mc particles, separated into track-like, shower-like and neutron branches. This method collects together all track-like particles (i.e. not electron, photon or neutron) downstream of the root particle, stopping at a leading shower or neutron and then storing that leading shower or neutron in a separate list. More...
static void	GetAllAncestorMCParticles (const pandora::MCParticle *const pMCParticle, pandora::MCParticleList &ancestorMCParticleList)
	Get all ancestor mc particles. More...
static void	GetMCPrimaryMap (const pandora::MCParticleList *const pMCParticleList, MCRelationMap &mcPrimaryMap)
	Get mapping from individual mc particles (in a provided list) and their primary parent mc particles. More...
static void	GetMCLeadingMap (const pandora::MCParticleList *const pMCParticleList, MCRelationMap &mcLeadingMap)
	Get mapping from individual mc particles (in a provided list) and their leading parent mc particles. More...
static void	GetMCToSelfMap (const pandora::MCParticleList *const pMCParticleList, MCRelationMap &mcToSelfMap)
	Get mapping from individual mc particles (in a provided list) to themselves (to be used when not folding particles to their primaries) More...
static const pandora::MCParticle *	GetMainMCParticle (const pandora::ParticleFlowObject *const pPfo)
	Find the mc particle making the largest contribution to 2D clusters in a specified pfo. More...
static bool	SortByMomentum (const pandora::MCParticle *const pLhs, const pandora::MCParticle *const pRhs)
	Sort mc particles by their momentum. More...
static void	GetMCParticleToCaloHitMatches (const pandora::CaloHitList *const pCaloHitList, const MCRelationMap &mcToTargetMCMap, CaloHitToMCMap &hitToMCMap, MCContributionMap &mcToTrueHitListMap)
	Match calo hits to their parent particles. More...
static void	SelectReconstructableMCParticles (const pandora::MCParticleList *pMCParticleList, const pandora::CaloHitList *pCaloHitList, const PrimaryParameters &parameters, std::function< bool(const pandora::MCParticle *const)> fCriteria, MCContributionMap &selectedMCParticlesToHitsMap)
	Select target, reconstructable mc particles that match given criteria. More...
static void	SelectReconstructableTestBeamHierarchyMCParticles (const pandora::MCParticleList *pMCParticleList, const pandora::CaloHitList *pCaloHitList, const PrimaryParameters &parameters, std::function< bool(const pandora::MCParticle *const)> fCriteria, MCContributionMap &selectedMCParticlesToHitsMap)
	Select target, reconstructable mc particles in the relevant hierarchy that match given criteria. More...
static void	GetPfoToReconstructable2DHitsMap (const pandora::PfoList &pfoList, const MCContributionMap &selectedMCParticleToHitsMap, PfoContributionMap &pfoToReconstructable2DHitsMap, const bool foldBackHierarchy)
	Get mapping from Pfo to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle) More...
static void	GetTestBeamHierarchyPfoToReconstructable2DHitsMap (const pandora::PfoList &pfoList, const MCContributionMap &selectedMCParticleToHitsMap, PfoContributionMap &pfoToReconstructable2DHitsMap, const bool foldBackHierarchy)
	Get mapping from Pfo in reconstructed test beam hierarchy to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle) More...
static void	GetPfoToReconstructable2DHitsMap (const pandora::PfoList &pfoList, const MCContributionMapVector &selectedMCParticleToHitsMaps, PfoContributionMap &pfoToReconstructable2DHitsMap, const bool foldBackHierarchy)
	Get mapping from Pfo to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle) More...
static void	GetTestBeamHierarchyPfoToReconstructable2DHitsMap (const pandora::PfoList &pfoList, const MCContributionMapVector &selectedMCParticleToHitsMaps, PfoContributionMap &pfoToReconstructable2DHitsMap, const bool foldBackHierarchy)
	Get mapping from Pfo in reconstructed test beam hierarchy to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle) More...
static void	GetClusterToReconstructable2DHitsMap (const pandora::ClusterList &clusterList, const MCContributionMap &selectedMCToHitsMap, ClusterContributionMap &clusterToReconstructable2DHitsMap)
	Get mapping from cluster to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle) More...
static void	GetClusterToReconstructable2DHitsMap (const pandora::ClusterList &clusterList, const MCContributionMapVector &selectedMCToHitsMaps, ClusterContributionMap &clusterToReconstructable2DHitsMap)
	Get mapping from cluster to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle) More...
static void	GetPfoMCParticleHitSharingMaps (const PfoContributionMap &pfoToReconstructable2DHitsMap, const MCContributionMapVector &selectedMCParticleToHitsMaps, PfoToMCParticleHitSharingMap &pfoToMCParticleHitSharingMap, MCParticleToPfoHitSharingMap &mcParticleToPfoHitSharingMap)
	Get the mappings from Pfo -> pair (reconstructable MCparticles, number of reconstructable 2D hits shared with Pfo) reconstructable MCParticle -> pair (Pfo, number of reconstructable 2D hits shared with MCParticle) More...
static void	SelectCaloHits (const pandora::CaloHitList *const pCaloHitList, const MCRelationMap &mcToTargetMCMap, pandora::CaloHitList &selectedCaloHitList, const bool selectInputHits, const float maxPhotonPropagation)
	Select a subset of calo hits representing those that represent "reconstructable" regions of the event. More...
static bool	IsDescendentOf (const pandora::MCParticle *const pMCParticle, const int pdg, const bool isChargeSensitive=false)
	Determine if the MC particle is a descendent of a particle with the given PDG code. More...
static void	GetBreadthFirstHierarchyRepresentation (const pandora::MCParticle *const pMCParticle, pandora::MCParticleList &mcParticleList)
	Retrieve a linearised representation of the MC particle hierarchy in breadth first order. This iterates over the MC hierarchy in a manor that sees primaries at the front of the list, with progressively deeper tiers later in the list. This is useful for some visualisation cases. More...
static void	SelectParticlesByHitCount (const pandora::MCParticleVector &candidateTargets, const MCContributionMap &mcToTrueHitListMap, const MCRelationMap &mcToTargetMCMap, const PrimaryParameters &parameters, MCContributionMap &selectedMCParticlesToHitsMap)
	Filter an input vector of MCParticles to ensure they have sufficient good hits to be reconstructable. More...
static pandora::CaloHitList	GetSharedHits (const pandora::CaloHitList &hitListA, const pandora::CaloHitList &hitListB)
	Get the hits in the intersection of two hit lists. More...
static bool	IsBremsstrahlung (const pandora::MCParticle *const pMCParticle)
static bool	IsCapture (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle comes from a capture process. More...
static bool	IsDecay (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle comes from a decay process. More...
static bool	IsElasticScatter (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle came from an elastic scattering process. More...
static bool	IsInelasticScatter (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle came from an inelastic scattering process. More...
static bool	IsIonisation (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle comes from an ionisation process. More...
static bool	IsNuclear (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle comes from a nuclear interaction process. More...
static bool	IsPairProduction (const pandora::MCParticle *const pMCParticle)
	Check whether or not an MC particle comes from a pair production process. More...
static bool	AreTopologicallyContinuous (const pandora::MCParticle *const pMCParent, const pandora::MCParticle *const pMCChild, const float cosAngleTolerance)
	Determine if two MC particles are topologically continuous within a given tolerance. If the parent does not travel any distance, a travelling parent is sought and the comparison made between this and the child. If no travelling parent can be found, the particles are treated as continuous. More...

Static Private Member Functions
static void	CollectReconstructable2DHits (const pandora::ParticleFlowObject *const pPfo, const MCContributionMapVector &selectedMCParticleToHitsMaps, pandora::CaloHitList &reconstructableCaloHitList2D, const bool foldBackHierarchy)
	For a given Pfo, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle) More...
static void	CollectReconstructableTestBeamHierarchy2DHits (const pandora::ParticleFlowObject *const pPfo, const MCContributionMapVector &selectedMCParticleToHitsMaps, pandora::CaloHitList &reconstructableCaloHitList2D, const bool foldBackHierarchy)
	For a given Pfo, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle) and belong in the test beam particle interaction hierarchy. More...
static void	CollectReconstructable2DHits (const pandora::PfoList &pfoList, const MCContributionMapVector &selectedMCParticleToHitsMaps, pandora::CaloHitList &reconstructableCaloHitList2D)
	For a given Pfo list, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle) More...
static void	CollectReconstructable2DHits (const pandora::Cluster *const pCluster, const MCContributionMapVector &selectedMCParticleToHitsMaps, pandora::CaloHitList &reconstructableCaloHitList2D)
	For a given cluster, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle) More...
static void	SelectGoodCaloHits (const pandora::CaloHitList *const pSelectedCaloHitList, const MCRelationMap &mcToTargetMCMap, pandora::CaloHitList &selectedGoodCaloHitList, const bool selectInputHits, const float minHitSharingFraction)
	Apply further selection criteria to end up with a collection of "good" calo hits that can be use to define whether a target mc particle is reconstructable. More...
static void	SelectParticlesMatchingCriteria (const pandora::MCParticleVector &inputMCParticles, std::function< bool(const pandora::MCParticle *const)> fCriteria, pandora::MCParticleVector &selectedParticles, const PrimaryParameters &parameters, const bool isTestBeam)
	Select mc particles matching given criteria from an input list. More...
static bool	PassMCParticleChecks (const pandora::MCParticle *const pOriginalPrimary, const pandora::MCParticle *const pThisMCParticle, const pandora::MCParticle *const pHitMCParticle, const float maxPhotonPropagation)
	Whether it is possible to navigate from a primary mc particle to a downstream mc particle without "passing through" a neutron. More...

Detailed Description

LArMCParticleHelper class.

Definition at line 24 of file LArMCParticleHelper.h.

Member Typedef Documentation

typedef std::unordered_map<const pandora::CaloHit *, const pandora::MCParticle *> lar_content::LArMCParticleHelper::CaloHitToMCMap

Definition at line 32 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::CaloHit *, const pandora::ParticleFlowObject *> lar_content::LArMCParticleHelper::CaloHitToPfoMap

Definition at line 33 of file LArMCParticleHelper.h.

typedef std::pair<const pandora::Cluster *, pandora::CaloHitList> lar_content::LArMCParticleHelper::ClusterCaloHitListPair

Definition at line 44 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::Cluster *, pandora::CaloHitList> lar_content::LArMCParticleHelper::ClusterContributionMap

Definition at line 38 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::MCParticle *, pandora::CaloHitList> lar_content::LArMCParticleHelper::MCContributionMap

Definition at line 35 of file LArMCParticleHelper.h.

typedef std::vector<MCContributionMap> lar_content::LArMCParticleHelper::MCContributionMapVector

Definition at line 36 of file LArMCParticleHelper.h.

typedef std::pair<const pandora::MCParticle *, pandora::CaloHitList> lar_content::LArMCParticleHelper::MCParticleCaloHitListPair

Definition at line 42 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::MCParticle *, int> lar_content::LArMCParticleHelper::MCParticleIntMap

Definition at line 28 of file LArMCParticleHelper.h.

typedef std::map<const pandora::MCParticle *, PfoToSharedHitsVector> lar_content::LArMCParticleHelper::MCParticleToPfoHitSharingMap

Definition at line 50 of file LArMCParticleHelper.h.

typedef std::vector<MCParticleCaloHitListPair> lar_content::LArMCParticleHelper::MCParticleToSharedHitsVector

Definition at line 46 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::MCParticle *, const pandora::MCParticle *> lar_content::LArMCParticleHelper::MCRelationMap

Definition at line 27 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::MCParticle *, const pandora::ParticleFlowObject *> lar_content::LArMCParticleHelper::MCToPfoMap

Definition at line 30 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::MCParticle *, PfoContributionMap> lar_content::LArMCParticleHelper::MCToPfoMatchingMap

Definition at line 40 of file LArMCParticleHelper.h.

typedef std::pair<const pandora::ParticleFlowObject *, pandora::CaloHitList> lar_content::LArMCParticleHelper::PfoCaloHitListPair

Definition at line 43 of file LArMCParticleHelper.h.

typedef std::unordered_map<const pandora::ParticleFlowObject *, pandora::CaloHitList> lar_content::LArMCParticleHelper::PfoContributionMap

Definition at line 39 of file LArMCParticleHelper.h.

typedef std::map<const pandora::ParticleFlowObject *, MCParticleToSharedHitsVector> lar_content::LArMCParticleHelper::PfoToMCParticleHitSharingMap

Definition at line 49 of file LArMCParticleHelper.h.

typedef std::vector<PfoCaloHitListPair> lar_content::LArMCParticleHelper::PfoToSharedHitsVector

Definition at line 47 of file LArMCParticleHelper.h.

Member Function Documentation

bool lar_content::LArMCParticleHelper::AreTopologicallyContinuous ( const pandora::MCParticle *const  pMCParent, const pandora::MCParticle *const  pMCChild, const float  cosAngleTolerance  )

static

Determine if two MC particles are topologically continuous within a given tolerance. If the parent does not travel any distance, a travelling parent is sought and the comparison made between this and the child. If no travelling parent can be found, the particles are treated as continuous.

Parameters

pMCParent	The parent MC particle
pMCChild	The child MC particle
cosAngleTolerance	The cosine of the maximum acceptable angular deviation

Returns

True if the partiles are topologically continous, false otherwise.

Definition at line 959 of file LArMCParticleHelper.cc.

{
    CartesianVector childDirection{pMCChild->GetEndpoint() - pMCChild->GetVertex()};
    if (childDirection.GetMagnitude() < std::numeric_limits<float>::epsilon())
        return true;
    childDirection = childDirection.GetUnitVector();

    const MCParticle *pMCUpstream{pMCParent};
    while (true)
    {
        CartesianVector parentDirection{pMCUpstream->GetEndpoint() - pMCUpstream->GetVertex()};
        if (parentDirection.GetMagnitude() > std::numeric_limits<float>::epsilon())
        {
            parentDirection = parentDirection.GetUnitVector();
            return parentDirection.GetDotProduct(childDirection) >= cosAngleTolerance;
        }
        else
        {
            const MCParticleList &parentList{pMCUpstream->GetParentList()};
            const size_t size{parentList.size()};
            if (size == 1)
                pMCUpstream = parentList.front();
            else if (size == 0)
                return true;
            else
                return false;
        }
    }

    return false;
}

static void lar_content::LArMCParticleHelper::CollectReconstructable2DHits ( const pandora::ParticleFlowObject *const  pPfo, const MCContributionMapVector &  selectedMCParticleToHitsMaps, pandora::CaloHitList &  reconstructableCaloHitList2D, const bool  foldBackHierarchy  )

staticprivate

For a given Pfo, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pPfo	the input pfo
selectedMCParticleToHitsMaps	the input mappings from selected reconstructable MCParticles to hits
reconstructableCaloHitList2D	the output list of reconstructable 2D calo hits in the input pfo
foldBackHierarchy	whether to fold the particle hierarchy back to primaries

static void lar_content::LArMCParticleHelper::CollectReconstructable2DHits ( const pandora::PfoList &  pfoList, const MCContributionMapVector &  selectedMCParticleToHitsMaps, pandora::CaloHitList &  reconstructableCaloHitList2D  )

staticprivate

For a given Pfo list, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pfoList	the input pfo list
selectedMCParticleToHitsMaps	the input mappings from selected reconstructable MCParticles to hits
reconstructableCaloHitList2D	the output list of reconstructable 2D calo hits in the input pfo

void lar_content::LArMCParticleHelper::CollectReconstructable2DHits ( const pandora::Cluster *const  pCluster, const MCContributionMapVector &  selectedMCParticleToHitsMaps, pandora::CaloHitList &  reconstructableCaloHitList2D  )

staticprivate

For a given cluster, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pCluster	the input cluster
selectedMCToHitsMaps	the input mappings from selected reconstructable MCParticles to hits
reconstructableCaloHitList2D	the output list of reconstructable 2D calo hits in the input pfo

Definition at line 1082 of file LArMCParticleHelper.cc.

{
    const CaloHitList &isolatedCaloHitList{pCluster->GetIsolatedCaloHitList()};
    CaloHitList caloHitList;
    pCluster->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
    for (const CaloHit *pCaloHit : isolatedCaloHitList)
        caloHitList.push_back(pCaloHit);

    // Filter for only reconstructable hits
    for (const CaloHit *const pCaloHit : caloHitList)
    {
        bool isTargetHit{false};
        for (const MCContributionMap &mcParticleToHitsMap : selectedMCToHitsMaps)
        { // ATTN This map is unordered, but this does not impact search for specific target hit
            for (const MCContributionMap::value_type &mapEntry : mcParticleToHitsMap)
            {
                if (std::find(mapEntry.second.begin(), mapEntry.second.end(), pCaloHit) != mapEntry.second.end())
                {
                    isTargetHit = true;
                    break;
                }
            }
            if (isTargetHit)
                break;
        }

        if (isTargetHit)
            reconstructableCaloHitList2D.push_back(pCaloHit);
    }
}

void lar_content::LArMCParticleHelper::CollectReconstructableTestBeamHierarchy2DHits ( const pandora::ParticleFlowObject *const  pPfo, const MCContributionMapVector &  selectedMCParticleToHitsMaps, pandora::CaloHitList &  reconstructableCaloHitList2D, const bool  foldBackHierarchy  )

staticprivate

For a given Pfo, collect the hits which are reconstructable (=good hits belonging to a selected reconstructable MCParticle) and belong in the test beam particle interaction hierarchy.

Parameters

pPfo	the input pfo
selectedMCParticleToHitsMaps	the input mappings from selected reconstructable MCParticles to hits
reconstructableCaloHitList2D	the output list of reconstructable 2D calo hits in the input pfo
foldBackHierarchy	whether to fold the particle hierarchy back to leading particles

Definition at line 1016 of file LArMCParticleHelper.cc.

{

    PfoList pfoList;
    // If foldBackHierarchy collect all 2D calo hits in pfo hierarchy
    // else collect hits directly belonging to pfo
    if (foldBackHierarchy)
    {
        // ATTN: Only collect downstream pfos for daughter test beam particles & cosmics
        if (pPfo->GetParentPfoList().empty() && LArPfoHelper::IsTestBeam(pPfo))
        {
            pfoList.push_back(pPfo);
        }
        else
        {
            LArPfoHelper::GetAllDownstreamPfos(pPfo, pfoList);
        }
    }
    else
    {
        pfoList.push_back(pPfo);
    }

    LArMCParticleHelper::CollectReconstructable2DHits(pfoList, selectedMCParticleToHitsMaps, reconstructableCaloHitList2D);
}

bool lar_content::LArMCParticleHelper::DoesLeadingMeetCriteria ( const pandora::MCParticle *const  pMCParticle, std::function< bool(const pandora::MCParticle *const)>  fCriteria  )

static

Returns true if passed particle whose leading meets the passed criteria.

Parameters

pMCParticle	the input mc particle
fCriteria	the given criteria

Definition at line 61 of file LArMCParticleHelper.cc.

{
    try
    {
        const MCParticle *const pLeadingMCParticle = LArMCParticleHelper::GetLeadingMCParticle(pMCParticle);
        return fCriteria(pLeadingMCParticle);
    }
    catch (const StatusCodeException &)
    {
    }

    return false;
}

bool lar_content::LArMCParticleHelper::DoesPrimaryMeetCriteria ( const pandora::MCParticle *const  pMCParticle, std::function< bool(const pandora::MCParticle *const)>  fCriteria  )

static

Returns true if passed particle whose primary meets the passed criteria.

Parameters

pMCParticle	the input mc particle
fCriteria	the given criteria

Definition at line 45 of file LArMCParticleHelper.cc.

{
    try
    {
        const MCParticle *const pPrimaryMCParticle = LArMCParticleHelper::GetPrimaryMCParticle(pMCParticle);
        return fCriteria(pPrimaryMCParticle);
    }
    catch (const StatusCodeException &)
    {
    }

    return false;
}

void lar_content::LArMCParticleHelper::GetAllAncestorMCParticles ( const pandora::MCParticle *const  pMCParticle, pandora::MCParticleList &  ancestorMCParticleList  )

static

Get all ancestor mc particles.

Parameters

pMCParticle	the input mc particle
ancestorMCParticleList	the output ancestor mc particle list

Definition at line 290 of file LArMCParticleHelper.cc.

{
    const MCParticleList &parentMCParticleList = pMCParticle->GetParentList();
    if (parentMCParticleList.empty())
        return;
    if (parentMCParticleList.size() != 1)
        throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

    const MCParticle *pParentMCParticle = *parentMCParticleList.begin();
    if (std::find(ancestorMCParticleList.begin(), ancestorMCParticleList.end(), pParentMCParticle) == ancestorMCParticleList.end())
    {
        ancestorMCParticleList.push_back(pParentMCParticle);
        LArMCParticleHelper::GetAllAncestorMCParticles(pParentMCParticle, ancestorMCParticleList);
    }
}

void lar_content::LArMCParticleHelper::GetAllDescendentMCParticles ( const pandora::MCParticle *const  pMCParticle, pandora::MCParticleList &  descendentMCParticleList  )

static

Get all descendent mc particles.

Parameters

pMCParticle	the input mc particle
descendentMCParticleList	the output descendent mc particle list

Definition at line 249 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *pDaughterMCParticle : pMCParticle->GetDaughterList())
    {
        if (std::find(descendentMCParticleList.begin(), descendentMCParticleList.end(), pDaughterMCParticle) == descendentMCParticleList.end())
        {
            descendentMCParticleList.emplace_back(pDaughterMCParticle);
            LArMCParticleHelper::GetAllDescendentMCParticles(pDaughterMCParticle, descendentMCParticleList);
        }
    }
}

static void lar_content::LArMCParticleHelper::GetAllDescendentMCParticles ( const pandora::MCParticle *const  pMCParticle, pandora::MCParticleList &  descendentTrackParticles, pandora::MCParticleList &  leadingShowerParticles, pandora::MCParticleList &  leadingNeutrons  )

static

Get all descendent mc particles, separated into track-like, shower-like and neutron branches. This method collects together all track-like particles (i.e. not electron, photon or neutron) downstream of the root particle, stopping at a leading shower or neutron and then storing that leading shower or neutron in a separate list.

Parameters

pMCParticle	the input mc particle
descendentTrackParticles	the output list of descendent track-like particles
leadingShowerParticles	the output list of leading shower particles
leadingNeutrons	the output list of leading neutrons

void lar_content::LArMCParticleHelper::GetBreadthFirstHierarchyRepresentation ( const pandora::MCParticle *const  pMCParticle, pandora::MCParticleList &  mcParticleList  )

static

Retrieve a linearised representation of the MC particle hierarchy in breadth first order. This iterates over the MC hierarchy in a manor that sees primaries at the front of the list, with progressively deeper tiers later in the list. This is useful for some visualisation cases.

Parameters

pMCParticle	an MC particle in the hierarchy - can be any particle
mcParticleList	the output MC particle list

Definition at line 1170 of file LArMCParticleHelper.cc.

{
    const MCParticle *const pRoot{LArMCParticleHelper::GetParentMCParticle(pMCParticle)};
    MCParticleList queue;
    mcParticleList.emplace_back(pRoot);
    queue.emplace_back(pRoot);

    while (!queue.empty())
    {
        const MCParticleList &daughters{queue.front()->GetDaughterList()};
        queue.pop_front();
        for (const MCParticle *pDaughter : daughters)
        {
            mcParticleList.emplace_back(pDaughter);
            queue.emplace_back(pDaughter);
        }
    }
}

void lar_content::LArMCParticleHelper::GetClusterToReconstructable2DHitsMap ( const pandora::ClusterList &  clusterList, const MCContributionMap &  selectedMCToHitsMap, ClusterContributionMap &  clusterToReconstructable2DHitsMap  )

static

Get mapping from cluster to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle)

Parameters

clusterList	the input list of clusters
selectedMCToHitsMap	the input mapping from selected reconstructable MCParticles to their hits
clusterToReconstructable2DHitsMap	the output mapping from clusters to their reconstructable 2D hits

Definition at line 736 of file LArMCParticleHelper.cc.

{
    LArMCParticleHelper::GetClusterToReconstructable2DHitsMap(clusterList, MCContributionMapVector({selectedMCToHitsMap}), clusterToReconstructable2DHitsMap);
}

void lar_content::LArMCParticleHelper::GetClusterToReconstructable2DHitsMap ( const pandora::ClusterList &  clusterList, const MCContributionMapVector &  selectedMCToHitsMaps, ClusterContributionMap &  clusterToReconstructable2DHitsMap  )

static

Get mapping from cluster to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle)

Parameters

clusterList	the input list of clusters
selectedMCToHitsMaps	the input vector of mappings from selected reconstructable MCParticles to their hits
clusterToReconstructable2DHitsMap	the output mapping from cluster to their reconstructable 2D hits

Definition at line 744 of file LArMCParticleHelper.cc.

{
    for (const Cluster *const pCluster : clusterList)
    {
        CaloHitList caloHitList;
        LArMCParticleHelper::CollectReconstructable2DHits(pCluster, selectedMCToHitsMaps, caloHitList);

        if (!clusterToReconstructable2DHitsMap.insert(ClusterContributionMap::value_type(pCluster, caloHitList)).second)
            throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
    }
}

int lar_content::LArMCParticleHelper::GetHierarchyTier ( const pandora::MCParticle *const  pMCParticle )

static

Determine the position in the hierarchy for the MCParticle.

Parameters

pMCParticle

the address of the mc particle

Returns

integer

Definition at line 173 of file LArMCParticleHelper.cc.

{
    const MCParticle *pParentMCParticle = pMCParticle;
    int tier(0);

    while (pParentMCParticle->GetParentList().empty() == false)
    {
        if (1 != pParentMCParticle->GetParentList().size())
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        pParentMCParticle = *(pParentMCParticle->GetParentList().begin());
        ++tier;
    }

    return tier;
}

const MCParticle * lar_content::LArMCParticleHelper::GetLeadingMCParticle ( const pandora::MCParticle *const  pMCParticle, const int  hierarchyTierLimit = 1  )

static

Get the leading particle in the hierarchy, for use at ProtoDUNE.

Parameters

pMCParticle

the input mc particle

Returns

address of the primary parent mc particle

Definition at line 369 of file LArMCParticleHelper.cc.

{
    // ATTN: If not beam particle return primary particle
    const bool isBeamParticle(LArMCParticleHelper::IsBeamParticle(LArMCParticleHelper::GetParentMCParticle(pMCParticle)));

    if (!isBeamParticle)
        return LArMCParticleHelper::GetPrimaryMCParticle(pMCParticle);

    // Navigate upward through MC daughter/parent links - collect this particle and all its parents
    MCParticleVector mcVector;

    const MCParticle *pParentMCParticle = pMCParticle;
    mcVector.push_back(pParentMCParticle);

    while (!pParentMCParticle->GetParentList().empty())
    {
        if (1 != pParentMCParticle->GetParentList().size())
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        pParentMCParticle = *(pParentMCParticle->GetParentList().begin());
        mcVector.push_back(pParentMCParticle);
    }

    int hierarchyTier(0);
    const MCParticle *pLeadingMCParticle(nullptr);

    // Navigate downward through MC parent/daughter links - return the first long-lived charged particle
    for (MCParticleVector::const_reverse_iterator iter = mcVector.rbegin(), iterEnd = mcVector.rend(); iter != iterEnd; ++iter)
    {
        const MCParticle *const pNextParticle = *iter;

        // ATTN: Squash any invisible particles (e.g. pizero)
        if (!LArMCParticleHelper::IsVisible(pNextParticle))
            continue;

        if (hierarchyTier <= hierarchyTierLimit)
            pLeadingMCParticle = pNextParticle;

        hierarchyTier++;
    }

    if (!pLeadingMCParticle)
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    return pLeadingMCParticle;
}

void lar_content::LArMCParticleHelper::GetLeadingMCParticleList ( const pandora::MCParticleList *const  pMCParticleList, pandora::MCParticleVector &  mcLeadingVector  )

static

Get vector of leading MC particles from an input list of MC particles.

Parameters

pMCParticleList	the input mc particle list
mcLeadingVector	the output mc particle vector

Definition at line 321 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        const bool isBeamParticle(LArMCParticleHelper::IsBeamParticle(LArMCParticleHelper::GetParentMCParticle(pMCParticle)));

        if ((isBeamParticle && LArMCParticleHelper::IsLeading(pMCParticle)) || (!isBeamParticle && LArMCParticleHelper::IsPrimary(pMCParticle)))
        {
            mcLeadingVector.push_back(pMCParticle);
        }
    }

    std::sort(mcLeadingVector.begin(), mcLeadingVector.end(), LArMCParticleHelper::SortByMomentum);
}

const MCParticle * lar_content::LArMCParticleHelper::GetMainMCParticle ( const pandora::ParticleFlowObject *const  pPfo )

static

Find the mc particle making the largest contribution to 2D clusters in a specified pfo.

Parameters

pPfo	address of the pfo to examine

Returns

address of the main mc particle

Definition at line 462 of file LArMCParticleHelper.cc.

{
    ClusterList clusterList;
    LArPfoHelper::GetTwoDClusterList(pPfo, clusterList);
    return MCParticleHelper::GetMainMCParticle(&clusterList);
}

void lar_content::LArMCParticleHelper::GetMCLeadingMap ( const pandora::MCParticleList *const  pMCParticleList, MCRelationMap &  mcLeadingMap  )

static

Get mapping from individual mc particles (in a provided list) and their leading parent mc particles.

Parameters

pMCParticleList	the input mc particle list
mcLeadingMap	the output mapping between mc particles and their leading parent

Definition at line 435 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        try
        {
            const MCParticle *const pLeadingMCParticle = LArMCParticleHelper::GetLeadingMCParticle(pMCParticle);
            mcLeadingMap[pMCParticle] = pLeadingMCParticle;
        }
        catch (const StatusCodeException &)
        {
        }
    }
}

void lar_content::LArMCParticleHelper::GetMCParticleToCaloHitMatches ( const pandora::CaloHitList *const  pCaloHitList, const MCRelationMap &  mcToTargetMCMap, CaloHitToMCMap &  hitToMCMap, MCContributionMap &  mcToTrueHitListMap  )

static

Match calo hits to their parent particles.

Parameters

pCaloHitList	the input list of calo hits
mcToTargetMCMap	the mc particle to target (primary or self) mc particle map
hitToMCMap	output mapping between calo hits and their main MC particle
mcToTrueHitListMap	output mapping between MC particles and their associated hits

Definition at line 497 of file LArMCParticleHelper.cc.

{
    for (const CaloHit *const pCaloHit : *pCaloHitList)
    {
        try
        {
            const MCParticle *const pHitParticle(MCParticleHelper::GetMainMCParticle(pCaloHit));
            const MCParticle *pTargetParticle(pHitParticle);

            // ATTN Do not map back to target if mc to primary mc map or mc to self map not provided
            if (!mcToTargetMCMap.empty())
            {
                MCRelationMap::const_iterator mcIter = mcToTargetMCMap.find(pHitParticle);

                if (mcToTargetMCMap.end() == mcIter)
                    continue;

                pTargetParticle = mcIter->second;
            }

            mcToTrueHitListMap[pTargetParticle].push_back(pCaloHit);
            hitToMCMap[pCaloHit] = pTargetParticle;
        }
        catch (StatusCodeException &statusCodeException)
        {
            if (STATUS_CODE_FAILURE == statusCodeException.GetStatusCode())
                throw statusCodeException;
        }
    }
}

void lar_content::LArMCParticleHelper::GetMCPrimaryMap ( const pandora::MCParticleList *const  pMCParticleList, MCRelationMap &  mcPrimaryMap  )

static

Get mapping from individual mc particles (in a provided list) and their primary parent mc particles.

Parameters

pMCParticleList	the input mc particle list
mcPrimaryMap	the output mapping between mc particles and their parents

Definition at line 418 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        try
        {
            const MCParticle *const pPrimaryMCParticle = LArMCParticleHelper::GetPrimaryMCParticle(pMCParticle);
            mcPrimaryMap[pMCParticle] = pPrimaryMCParticle;
        }
        catch (const StatusCodeException &)
        {
        }
    }
}

void lar_content::LArMCParticleHelper::GetMCToSelfMap ( const pandora::MCParticleList *const  pMCParticleList, MCRelationMap &  mcToSelfMap  )

static

Get mapping from individual mc particles (in a provided list) to themselves (to be used when not folding particles to their primaries)

Parameters

pMCParticleList	the input mc particle list
mcToSelfMap	the output mapping between mc particles and themselves

Definition at line 452 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        mcToSelfMap[pMCParticle] = pMCParticle;
    }
}

unsigned int lar_content::LArMCParticleHelper::GetNuanceCode ( const pandora::MCParticle *const  pMCParticle )

static

Get the nuance code of an MCParticle.

Definition at line 119 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *const pLArMCParticle(dynamic_cast<const LArMCParticle *>(pMCParticle));
    if (pLArMCParticle)
        return pLArMCParticle->GetNuanceCode();

    std::cout << "LArMCParticleHelper::GetNuanceCode - Error: Can't cast to LArMCParticle" << std::endl;
    throw StatusCodeException(STATUS_CODE_NOT_ALLOWED);
}

const MCParticle * lar_content::LArMCParticleHelper::GetParentMCParticle ( const pandora::MCParticle *const  pMCParticle )

static

Get the parent mc particle.

Parameters

pMCParticle

the input mc particle

Returns

address of the parent mc particle

Definition at line 232 of file LArMCParticleHelper.cc.

{
    const MCParticle *pParentMCParticle = pMCParticle;

    while (pParentMCParticle->GetParentList().empty() == false)
    {
        if (1 != pParentMCParticle->GetParentList().size())
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        pParentMCParticle = *(pParentMCParticle->GetParentList().begin());
    }

    return pParentMCParticle;
}

void lar_content::LArMCParticleHelper::GetPfoMCParticleHitSharingMaps ( const PfoContributionMap &  pfoToReconstructable2DHitsMap, const MCContributionMapVector &  selectedMCParticleToHitsMaps, PfoToMCParticleHitSharingMap &  pfoToMCParticleHitSharingMap, MCParticleToPfoHitSharingMap &  mcParticleToPfoHitSharingMap  )

static

Get the mappings from Pfo -> pair (reconstructable MCparticles, number of reconstructable 2D hits shared with Pfo) reconstructable MCParticle -> pair (Pfo, number of reconstructable 2D hits shared with MCParticle)

Parameters

pfoToReconstructable2DHitsMap	the input mapping from Pfos to reconstructable 2D hits
selectedMCParticleToHitsMaps	the input mappings from selected reconstructable MCParticles to hits
pfoToMCParticleHitSharingMap	the output mapping from Pfos to selected reconstructable MCParticles and the number hits shared
mcParticleToPfoHitSharingMap	the output mapping from selected reconstructable MCParticles to Pfos and the number hits shared

Definition at line 671 of file LArMCParticleHelper.cc.

{
    PfoVector sortedPfos;
    for (const auto &mapEntry : pfoToReconstructable2DHitsMap)
        sortedPfos.push_back(mapEntry.first);
    std::sort(sortedPfos.begin(), sortedPfos.end(), LArPfoHelper::SortByNHits);

    for (const ParticleFlowObject *const pPfo : sortedPfos)
    {
        for (const MCContributionMap &mcParticleToHitsMap : selectedMCParticleToHitsMaps)
        {
            MCParticleVector sortedMCParticles;
            for (const auto &mapEntry : mcParticleToHitsMap)
                sortedMCParticles.push_back(mapEntry.first);
            std::sort(sortedMCParticles.begin(), sortedMCParticles.end(), PointerLessThan<MCParticle>());

            for (const MCParticle *const pMCParticle : sortedMCParticles)
            {
                // Add map entries for this Pfo & MCParticle if required
                if (pfoToMCParticleHitSharingMap.find(pPfo) == pfoToMCParticleHitSharingMap.end())
                    if (!pfoToMCParticleHitSharingMap.insert(PfoToMCParticleHitSharingMap::value_type(pPfo, MCParticleToSharedHitsVector())).second)
                        throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT); // ATTN maybe overkill

                if (mcParticleToPfoHitSharingMap.find(pMCParticle) == mcParticleToPfoHitSharingMap.end())
                    if (!mcParticleToPfoHitSharingMap.insert(MCParticleToPfoHitSharingMap::value_type(pMCParticle, PfoToSharedHitsVector())).second)
                        throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);

                // Check this Pfo & MCParticle pairing hasn't already been checked
                MCParticleToSharedHitsVector &mcHitPairs(pfoToMCParticleHitSharingMap.at(pPfo));
                PfoToSharedHitsVector &pfoHitPairs(mcParticleToPfoHitSharingMap.at(pMCParticle));

                if (std::any_of(mcHitPairs.begin(), mcHitPairs.end(),
                        [&](const MCParticleCaloHitListPair &pair) { return (pair.first == pMCParticle); }))
                    throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);

                if (std::any_of(pfoHitPairs.begin(), pfoHitPairs.end(), [&](const PfoCaloHitListPair &pair) { return (pair.first == pPfo); }))
                    throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);

                // Add records to maps if there are any shared hits
                const CaloHitList sharedHits(
                    LArMCParticleHelper::GetSharedHits(pfoToReconstructable2DHitsMap.at(pPfo), mcParticleToHitsMap.at(pMCParticle)));

                if (!sharedHits.empty())
                {
                    mcHitPairs.push_back(MCParticleCaloHitListPair(pMCParticle, sharedHits));
                    pfoHitPairs.push_back(PfoCaloHitListPair(pPfo, sharedHits));

                    std::sort(mcHitPairs.begin(), mcHitPairs.end(), [](const MCParticleCaloHitListPair &a, const MCParticleCaloHitListPair &b) -> bool {
                        return ((a.second.size() != b.second.size()) ? a.second.size() > b.second.size()
                                                                     : LArMCParticleHelper::SortByMomentum(a.first, b.first));
                    });

                    std::sort(pfoHitPairs.begin(), pfoHitPairs.end(), [](const PfoCaloHitListPair &a, const PfoCaloHitListPair &b) -> bool {
                        return ((a.second.size() != b.second.size()) ? a.second.size() > b.second.size() : LArPfoHelper::SortByNHits(a.first, b.first));
                    });
                }
            }
        }
    }
}

static void lar_content::LArMCParticleHelper::GetPfoToReconstructable2DHitsMap ( const pandora::PfoList &  pfoList, const MCContributionMap &  selectedMCParticleToHitsMap, PfoContributionMap &  pfoToReconstructable2DHitsMap, const bool  foldBackHierarchy  )

static

Get mapping from Pfo to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pfoList	the input list of Pfos
selectedMCParticleToHitsMap	the input mapping from selected reconstructable MCParticles to their hits
pfoToReconstructable2DHitsMap	the output mapping from Pfos to their reconstructable 2D hits
foldBackHierarchy	whether to fold the particle hierarchy back to the primaries

static void lar_content::LArMCParticleHelper::GetPfoToReconstructable2DHitsMap ( const pandora::PfoList &  pfoList, const MCContributionMapVector &  selectedMCParticleToHitsMaps, PfoContributionMap &  pfoToReconstructable2DHitsMap, const bool  foldBackHierarchy  )

static

Get mapping from Pfo to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pfoList	the input list of Pfos
selectedMCParticleToHitsMaps	the input vector of mappings from selected reconstructable MCParticles to their hits
pfoToReconstructable2DHitsMap	the output mapping from Pfos to their reconstructable 2D hits
foldToHierarchy	whether to fold the particle hierarchy back to the primaries

const MCParticle * lar_content::LArMCParticleHelper::GetPrimaryMCParticle ( const pandora::MCParticle *const  pMCParticle )

static

Get the primary parent mc particle.

Parameters

pMCParticle

the input mc particle

Returns

address of the primary parent mc particle

Definition at line 338 of file LArMCParticleHelper.cc.

{
    // Navigate upward through MC daughter/parent links - collect this particle and all its parents
    MCParticleVector mcVector;

    const MCParticle *pParentMCParticle = pMCParticle;
    mcVector.push_back(pParentMCParticle);

    while (!pParentMCParticle->GetParentList().empty())
    {
        if (1 != pParentMCParticle->GetParentList().size())
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        pParentMCParticle = *(pParentMCParticle->GetParentList().begin());
        mcVector.push_back(pParentMCParticle);
    }

    // Navigate downward through MC parent/daughter links - return the first long-lived charged particle
    for (MCParticleVector::const_reverse_iterator iter = mcVector.rbegin(), iterEnd = mcVector.rend(); iter != iterEnd; ++iter)
    {
        const MCParticle *const pNextParticle = *iter;

        if (LArMCParticleHelper::IsVisible(pNextParticle))
            return pNextParticle;
    }

    throw StatusCodeException(STATUS_CODE_NOT_FOUND);
}

void lar_content::LArMCParticleHelper::GetPrimaryMCParticleList ( const pandora::MCParticleList *const  pMCParticleList, pandora::MCParticleVector &  mcPrimaryVector  )

static

Get vector of primary MC particles from an input list of MC particles.

Parameters

pMCParticleList	the input mc particle list
mcPrimaryVector	the output mc particle vector

Definition at line 308 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        if (LArMCParticleHelper::IsPrimary(pMCParticle))
            mcPrimaryVector.push_back(pMCParticle);
    }

    std::sort(mcPrimaryVector.begin(), mcPrimaryVector.end(), LArMCParticleHelper::SortByMomentum);
}

CaloHitList lar_content::LArMCParticleHelper::GetSharedHits ( const pandora::CaloHitList &  hitListA, const pandora::CaloHitList &  hitListB  )

static

Get the hits in the intersection of two hit lists.

Parameters

hitListA	an input hit list
hitListB	another input hit list

Returns

The hits that are found in both hitListA and hitListB

Definition at line 944 of file LArMCParticleHelper.cc.

{
    CaloHitList sharedHits;

    for (const CaloHit *const pCaloHit : hitListA)
    {
        if (std::find(hitListB.begin(), hitListB.end(), pCaloHit) != hitListB.end())
            sharedHits.push_back(pCaloHit);
    }

    return sharedHits;
}

static void lar_content::LArMCParticleHelper::GetTestBeamHierarchyPfoToReconstructable2DHitsMap ( const pandora::PfoList &  pfoList, const MCContributionMap &  selectedMCParticleToHitsMap, PfoContributionMap &  pfoToReconstructable2DHitsMap, const bool  foldBackHierarchy  )

static

Get mapping from Pfo in reconstructed test beam hierarchy to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pfoList	the input list of Pfos
selectedMCParticleToHitsMap	the input mapping from selected reconstructable MCParticles to their hits
pfoToReconstructable2DHitsMap	the output mapping from Pfos to their reconstructable 2D hits
foldBackHierarchy	whether to fold the particle hierarchy back to the leading particles

static void lar_content::LArMCParticleHelper::GetTestBeamHierarchyPfoToReconstructable2DHitsMap ( const pandora::PfoList &  pfoList, const MCContributionMapVector &  selectedMCParticleToHitsMaps, PfoContributionMap &  pfoToReconstructable2DHitsMap, const bool  foldBackHierarchy  )

static

Get mapping from Pfo in reconstructed test beam hierarchy to reconstructable 2D hits (=good hits belonging to a selected reconstructable MCParticle)

Parameters

pfoList	the input list of Pfos
selectedMCParticleToHitsMaps	the input vector of mappings from selected reconstructable MCParticles to their hits
pfoToReconstructable2DHitsMap	the output mapping from Pfos to their reconstructable 2D hits
foldBackHierarchy	whether to fold the particle hierarchy back to the leading particles

void lar_content::LArMCParticleHelper::GetTrueNeutrinos ( const pandora::MCParticleList *const  pMCParticleList, pandora::MCParticleVector &  trueNeutrinos  )

static

Get neutrino MC particles from an input MC particle list.

Parameters

pMCParticleList	the input MC particle list
trueNeutrinos	to receive the vector of neutrino MC particles

Definition at line 206 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        if (LArMCParticleHelper::IsNeutrino(pMCParticle))
            trueNeutrinos.push_back(pMCParticle);
    }

    std::sort(trueNeutrinos.begin(), trueNeutrinos.end(), LArMCParticleHelper::SortByMomentum);
}

void lar_content::LArMCParticleHelper::GetTrueTestBeamParticles ( const pandora::MCParticleList *const  pMCParticleList, pandora::MCParticleVector &  trueTestBeamParticles  )

static

Get triggered test beam MC particles from an input MC particle list.

Parameters

pMCParticleList	the input MC particle list
trueTestBeamParticles	to receive the vector of neutrino MC particles

Definition at line 219 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : *pMCParticleList)
    {
        if (LArMCParticleHelper::IsTriggeredBeamParticle(pMCParticle))
            trueTestBeamParticles.push_back(pMCParticle);
    }

    std::sort(trueTestBeamParticles.begin(), trueTestBeamParticles.end(), LArMCParticleHelper::SortByMomentum);
}

bool lar_content::LArMCParticleHelper::IsBeamNeutrinoFinalState ( const pandora::MCParticle *const  pMCParticle )

static

Returns true if passed a primary neutrino final state MCParticle.

Definition at line 77 of file LArMCParticleHelper.cc.

{
    const MCParticle *const pParentMCParticle(LArMCParticleHelper::GetParentMCParticle(pMCParticle));
    return (LArMCParticleHelper::IsPrimary(pMCParticle) && LArMCParticleHelper::IsNeutrino(pParentMCParticle));
}

bool lar_content::LArMCParticleHelper::IsBeamParticle ( const pandora::MCParticle *const  pMCParticle )

static

Returns true if passed a primary beam MCParticle.

Definition at line 93 of file LArMCParticleHelper.cc.

{
    const int nuance(LArMCParticleHelper::GetNuanceCode(pMCParticle));
    return (LArMCParticleHelper::IsPrimary(pMCParticle) && ((nuance == 2000) || (nuance == 2001)));
}

bool lar_content::LArMCParticleHelper::IsBremsstrahlung ( const pandora::MCParticle *const  pMCParticle )

static

Definition at line 759 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_E_BREM:
        case MC_PROC_MU_BREM:
        case MC_PROC_HAD_BREM:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsCapture ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle comes from a capture process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from capture

Definition at line 780 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_MU_MINUS_CAPTURE_AT_REST:
        case MC_PROC_N_CAPTURE:
        case MC_PROC_CHIPS_NUCLEAR_CAPTURE_AT_REST:
        case MC_PROC_HAD_FRITIOF_CAPTURE_AT_REST:
        case MC_PROC_HAD_BERTINI_CAPTURE_AT_REST:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsCosmicRay ( const pandora::MCParticle *const  pMCParticle )

static

Return true if passed a primary cosmic ray MCParticle.

Definition at line 110 of file LArMCParticleHelper.cc.

{
    const int nuance(LArMCParticleHelper::GetNuanceCode(pMCParticle));
    return (LArMCParticleHelper::IsPrimary(pMCParticle) &&
            ((nuance == 3000) || ((nuance == 0) && !LArMCParticleHelper::IsBeamNeutrinoFinalState(pMCParticle))));
}

bool lar_content::LArMCParticleHelper::IsDecay ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle comes from a decay process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from decay

Definition at line 803 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_DECAY:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsDescendentOf ( const pandora::MCParticle *const  pMCParticle, const int  pdg, const bool  isChargeSensitive = false  )

static

Determine if the MC particle is a descendent of a particle with the given PDG code.

Parameters

pMCParticle	the descendent particle
pdg	the PDG code of the ancestor particle
isChargeSensitive	whether or not to consider the sign of the PDG code when looking for the ancestor (default: false)

Returns

true if the MC particle has an ancestor with the matching PDG code, false otherwise

Definition at line 1150 of file LArMCParticleHelper.cc.

{
    const MCParticle *pCurrentParticle = pMCParticle;
    while (!pCurrentParticle->GetParentList().empty())
    {
        if (pCurrentParticle->GetParentList().size() > 1)
            throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);

        const MCParticle *pParent = *(pCurrentParticle->GetParentList().begin());
        const bool found{isChargeSensitive ? pParent->GetParticleId() == pdg : std::abs(pParent->GetParticleId()) == std::abs(pdg)};
        if (found)
            return true;
        pCurrentParticle = pParent;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsElasticScatter ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle came from an elastic scattering process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from an elastic scatter

Definition at line 822 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_COULOMB_SCAT:
        case MC_PROC_NEUTRON_INELASTIC:
        case MC_PROC_HAD_ELASTIC:
        case MC_PROC_RAYLEIGH:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsInelasticScatter ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle came from an inelastic scattering process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from an inelastic scatter

Definition at line 844 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_COMPT:
        case MC_PROC_PHOTON_INELASTIC:
        case MC_PROC_PROTON_INELASTIC:
        case MC_PROC_PI_PLUS_INELASTIC:
        case MC_PROC_PI_MINUS_INELASTIC:
        case MC_PROC_ION_INELASTIC:
        case MC_PROC_HE3_INELASTIC:
        case MC_PROC_ALPHA_INELASTIC:
        case MC_PROC_ANTI_HE3_INELASTIC:
        case MC_PROC_ANTI_ALPHA_INELASTIC:
        case MC_PROC_ANTI_DEUTERON_INELASTIC:
        case MC_PROC_ANTI_NEUTRON_INELASTIC:
        case MC_PROC_ANTI_PROTON_INELASTIC:
        case MC_PROC_ANTI_TRITON_INELASTIC:
        case MC_PROC_DEUTERON_INELASTIC:
        case MC_PROC_KAON_PLUS_INELASTIC:
        case MC_PROC_KAON_MINUS_INELASTIC:
        case MC_PROC_LAMBDA_INELASTIC:
        case MC_PROC_TRITON_INELASTIC:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsIonisation ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle comes from an ionisation process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from ionisation

Definition at line 881 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_E_IONI:
        case MC_PROC_MU_IONI:
        case MC_PROC_HAD_IONI:
        case MC_PROC_ION_IONI:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsLeading ( const pandora::MCParticle *const  pMCParticle )

static

Whether a provided mc particle matches the implemented definition of being leading.

Parameters

pMCParticle

the address of the mc particle

Returns

boolean

Definition at line 158 of file LArMCParticleHelper.cc.

{
    try
    {
        return (LArMCParticleHelper::GetLeadingMCParticle(pMCParticle) == pMCParticle);
    }
    catch (const StatusCodeException &)
    {
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsLeadingBeamParticle ( const pandora::MCParticle *const  pMCParticle )

static

Returns true if passed a leading beam MCParticle.

Definition at line 101 of file LArMCParticleHelper.cc.

{
    // ATTN: Only the parent triggered beam particle has nuance code 2001
    const int parentNuance(LArMCParticleHelper::GetNuanceCode(LArMCParticleHelper::GetParentMCParticle(pMCParticle)));
    return (LArMCParticleHelper::IsLeading(pMCParticle) && (parentNuance == 2001 || parentNuance == 2000));
}

bool lar_content::LArMCParticleHelper::IsNeutrino ( const pandora::MCParticle *const  pMCParticle )

static

Whether a mc particle is a neutrino or antineutrino.

Parameters

pMCParticle

the input mc particle

Returns

boolean

Definition at line 131 of file LArMCParticleHelper.cc.

{
    const int nuance(LArMCParticleHelper::GetNuanceCode(pMCParticle));
    if ((nuance == 0) || (nuance == 2000) || (nuance == 2001) || (nuance == 3000))
        return false;

    const int absoluteParticleId(std::abs(pMCParticle->GetParticleId()));
    return ((NU_E == absoluteParticleId) || (NU_MU == absoluteParticleId) || (NU_TAU == absoluteParticleId));
}

bool lar_content::LArMCParticleHelper::IsNuclear ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle comes from a nuclear interaction process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from nuclear interaction

Definition at line 903 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_ELECTRON_NUCLEAR:
        case MC_PROC_PHOTON_NUCLEAR:
        case MC_PROC_MU_NUCLEAR:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsPairProduction ( const pandora::MCParticle *const  pMCParticle )

static

Check whether or not an MC particle comes from a pair production process.

Parameters

pMCParticle

The MC particle to consider

Returns

Whether or not the MC particle came from pair production

Definition at line 924 of file LArMCParticleHelper.cc.

{
    const LArMCParticle *pLArMCParticle{dynamic_cast<const LArMCParticle *>(pMCParticle)};
    if (!pLArMCParticle)
        return false;

    switch (pLArMCParticle->GetProcess())
    {
        case MC_PROC_MU_PAIR_PROD:
        case MC_PROC_HAD_PAIR_PROD:
            return true;
        default:
            return false;
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsPrimary ( const pandora::MCParticle *const  pMCParticle )

static

Whether a provided mc particle matches the implemented definition of being primary.

Parameters

pMCParticle

the address of the mc particle

Returns

boolean

Definition at line 143 of file LArMCParticleHelper.cc.

{
    try
    {
        return (LArMCParticleHelper::GetPrimaryMCParticle(pMCParticle) == pMCParticle);
    }
    catch (const StatusCodeException &)
    {
    }

    return false;
}

bool lar_content::LArMCParticleHelper::IsTriggeredBeamParticle ( const pandora::MCParticle *const  pMCParticle )

static

Returns true if passed a primary triggered beam MCParticle.

Definition at line 85 of file LArMCParticleHelper.cc.

{
    const int nuance(LArMCParticleHelper::GetNuanceCode(pMCParticle));
    return (LArMCParticleHelper::IsPrimary(pMCParticle) && (nuance == 2001));
}

bool lar_content::LArMCParticleHelper::IsVisible ( const pandora::MCParticle *const  pMCParticle )

static

Whether a mc particle is visible (i.e. long-lived charged particle)

Parameters

pMCParticle

the input mc particle

Returns

boolean

Definition at line 192 of file LArMCParticleHelper.cc.

{
    const int absoluteParticleId(std::abs(pMCParticle->GetParticleId()));

    if ((E_MINUS == absoluteParticleId) || (MU_MINUS == absoluteParticleId) || (PI_PLUS == absoluteParticleId) || (K_PLUS == absoluteParticleId) ||
        (SIGMA_MINUS == absoluteParticleId) || (SIGMA_PLUS == absoluteParticleId) || (HYPERON_MINUS == absoluteParticleId) ||
        (PROTON == absoluteParticleId) || (PHOTON == absoluteParticleId) || (NEUTRON == absoluteParticleId))
        return true;

    return false;
}

bool lar_content::LArMCParticleHelper::PassMCParticleChecks ( const pandora::MCParticle *const  pOriginalPrimary, const pandora::MCParticle *const  pThisMCParticle, const pandora::MCParticle *const  pHitMCParticle, const float  maxPhotonPropagation  )

staticprivate

Whether it is possible to navigate from a primary mc particle to a downstream mc particle without "passing through" a neutron.

Parameters

pOriginalPrimary	the address of the original primary mc particle
pThisMCParticle	the address of the current mc particle in the primary decay chain
pHitMCParticle	the address of the mc particle associated to a calo hit
maxPhotonPropagation	the maximum photon propagation length

Returns

boolean

Definition at line 1316 of file LArMCParticleHelper.cc.

{
    if (NEUTRON == std::abs(pThisMCParticle->GetParticleId()))
        return false;

    if ((PHOTON == pThisMCParticle->GetParticleId()) && (PHOTON != pOriginalPrimary->GetParticleId()) &&
        (E_MINUS != std::abs(pOriginalPrimary->GetParticleId())))
    {
        if ((pThisMCParticle->GetEndpoint() - pThisMCParticle->GetVertex()).GetMagnitude() > maxPhotonPropagation)
            return false;
    }

    if (pThisMCParticle == pHitMCParticle)
        return true;

    for (const MCParticle *const pDaughterMCParticle : pThisMCParticle->GetDaughterList())
    {
        if (PassMCParticleChecks(pOriginalPrimary, pDaughterMCParticle, pHitMCParticle, maxPhotonPropagation))
            return true;
    }

    return false;
}

void lar_content::LArMCParticleHelper::SelectCaloHits ( const pandora::CaloHitList *const  pCaloHitList, const MCRelationMap &  mcToTargetMCMap, pandora::CaloHitList &  selectedCaloHitList, const bool  selectInputHits, const float  maxPhotonPropagation  )

static

Select a subset of calo hits representing those that represent "reconstructable" regions of the event.

Parameters

pCaloHitList	the address of the input calo hit list
mcToTargetMCMap	the mc particle to target (primary or self) mc particle map
selectedCaloHitList	to receive the populated selected calo hit list
selectInputHits	whether to select input hits
maxPhotonPropagation	the maximum photon propagation length

Definition at line 1116 of file LArMCParticleHelper.cc.

{
    if (!selectInputHits)
    {
        selectedCaloHitList.insert(selectedCaloHitList.end(), pCaloHitList->begin(), pCaloHitList->end());
        return;
    }

    for (const CaloHit *const pCaloHit : *pCaloHitList)
    {
        try
        {
            const MCParticle *const pHitParticle(MCParticleHelper::GetMainMCParticle(pCaloHit));

            LArMCParticleHelper::MCRelationMap::const_iterator mcIter = mcToTargetMCMap.find(pHitParticle);

            if (mcToTargetMCMap.end() == mcIter)
                continue;

            // ATTN With folding on or off, still require primary particle to review hierarchy details
            const MCParticle *const pPrimaryParticle = LArMCParticleHelper::GetPrimaryMCParticle(pHitParticle);

            if (PassMCParticleChecks(pPrimaryParticle, pPrimaryParticle, pHitParticle, maxPhotonPropagation))
                selectedCaloHitList.push_back(pCaloHit);
        }
        catch (const StatusCodeException &)
        {
        }
    }
}

void lar_content::LArMCParticleHelper::SelectGoodCaloHits ( const pandora::CaloHitList *const  pSelectedCaloHitList, const MCRelationMap &  mcToTargetMCMap, pandora::CaloHitList &  selectedGoodCaloHitList, const bool  selectInputHits, const float  minHitSharingFraction  )

staticprivate

Apply further selection criteria to end up with a collection of "good" calo hits that can be use to define whether a target mc particle is reconstructable.

Parameters

pSelectedCaloHitList	the address of the calo hit list (typically already been through some selection procedure)
mcToTargetMCMap	the mc particle to target (primary or self) mc particle map
selectedGoodCaloHitList	to receive the populated good selected calo hit list
selectInputHits	whether to select input hits
minHitSharingFraction	the minimum Hit sharing fraction

Definition at line 1231 of file LArMCParticleHelper.cc.

{
    if (!selectInputHits)
    {
        selectedGoodCaloHitList.insert(selectedGoodCaloHitList.end(), pSelectedCaloHitList->begin(), pSelectedCaloHitList->end());
        return;
    }

    for (const CaloHit *const pCaloHit : *pSelectedCaloHitList)
    {
        MCParticleVector mcParticleVector;
        for (const auto &mapEntry : pCaloHit->GetMCParticleWeightMap())
            mcParticleVector.push_back(mapEntry.first);
        std::sort(mcParticleVector.begin(), mcParticleVector.end(), PointerLessThan<MCParticle>());

        MCParticleWeightMap targetWeightMap;

        for (const MCParticle *const pMCParticle : mcParticleVector)
        {
            const float weight(pCaloHit->GetMCParticleWeightMap().at(pMCParticle));
            LArMCParticleHelper::MCRelationMap::const_iterator mcIter = mcToTargetMCMap.find(pMCParticle);

            if (mcToTargetMCMap.end() != mcIter)
                targetWeightMap[mcIter->second] += weight;
        }

        MCParticleVector mcTargetVector;
        for (const auto &mapEntry : targetWeightMap)
            mcTargetVector.push_back(mapEntry.first);
        std::sort(mcTargetVector.begin(), mcTargetVector.end(), PointerLessThan<MCParticle>());

        const MCParticle *pBestTargetParticle(nullptr);
        float bestTargetWeight(0.f), targetWeightSum(0.f);

        for (const MCParticle *const pTargetMCParticle : mcTargetVector)
        {
            const float targetWeight(targetWeightMap.at(pTargetMCParticle));
            targetWeightSum += targetWeight;

            if (targetWeight > bestTargetWeight)
            {
                bestTargetWeight = targetWeight;
                pBestTargetParticle = pTargetMCParticle;
            }
        }

        if (!pBestTargetParticle || (targetWeightSum < std::numeric_limits<float>::epsilon()) || ((bestTargetWeight / targetWeightSum) < minHitSharingFraction))
            continue;

        selectedGoodCaloHitList.push_back(pCaloHit);
    }
}

void lar_content::LArMCParticleHelper::SelectParticlesByHitCount ( const pandora::MCParticleVector &  candidateTargets, const MCContributionMap &  mcToTrueHitListMap, const MCRelationMap &  mcToTargetMCMap, const PrimaryParameters &  parameters, MCContributionMap &  selectedMCParticlesToHitsMap  )

static

Filter an input vector of MCParticles to ensure they have sufficient good hits to be reconstructable.

Parameters

candidateTargets	candidate reconstructable MCParticles
mcToTrueHitListMap	mapping from candidates reconstructable MCParticles to their true hits
mcToTargetMCMap	the mc particle to target (primary or self) mc particle map
parameters	validation parameters to decide when an MCParticle is considered reconstructable
selectedMCParticlesToHitsMap	the output mapping from selected mcparticles to their hits

Definition at line 1191 of file LArMCParticleHelper.cc.

{
    // Apply restrictions on the number of good hits associated with the MCParticles
    for (const MCParticle *const pMCTarget : candidateTargets)
    {
        MCContributionMap::const_iterator trueHitsIter = mcToTrueHitListMap.find(pMCTarget);
        if (mcToTrueHitListMap.end() == trueHitsIter)
            continue;

        const CaloHitList &caloHitList(trueHitsIter->second);

        // Remove shared hits where target particle deposits below threshold energy fraction
        CaloHitList goodCaloHitList;
        LArMCParticleHelper::SelectGoodCaloHits(
            &caloHitList, mcToTargetMCMap, goodCaloHitList, parameters.m_selectInputHits, parameters.m_minHitSharingFraction);

        if (goodCaloHitList.size() < parameters.m_minPrimaryGoodHits)
            continue;

        unsigned int nGoodViews(0);
        if (LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, goodCaloHitList) >= parameters.m_minHitsForGoodView)
            ++nGoodViews;

        if (LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, goodCaloHitList) >= parameters.m_minHitsForGoodView)
            ++nGoodViews;

        if (LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, goodCaloHitList) >= parameters.m_minHitsForGoodView)
            ++nGoodViews;

        if (nGoodViews < parameters.m_minPrimaryGoodViews)
            continue;

        if (!selectedMCParticlesToHitsMap.insert(MCContributionMap::value_type(pMCTarget, caloHitList)).second)
            throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
    }
}

void lar_content::LArMCParticleHelper::SelectParticlesMatchingCriteria ( const pandora::MCParticleVector &  inputMCParticles, std::function< bool(const pandora::MCParticle *const)>  fCriteria, pandora::MCParticleVector &  selectedParticles, const PrimaryParameters &  parameters, const bool  isTestBeam  )

staticprivate

Select mc particles matching given criteria from an input list.

Parameters

inputMCParticles	input vector of MCParticles
fCriteria	a function which returns a bool (= shouldSelect) for a given input MCParticle
selectedParticles	the output vector of particles selected
parameters	validation parameters to decide when an MCParticle is considered reconstructable
isTestBeam	whether the mc particles correspond to the test beam case or the neutrino case

Definition at line 1287 of file LArMCParticleHelper.cc.

{
    for (const MCParticle *const pMCParticle : inputMCParticles)
    {
        if (parameters.m_foldBackHierarchy)
        {
            if (!fCriteria(pMCParticle))
                continue;
        }
        else
        {
            if (isTestBeam)
            {
                if (!LArMCParticleHelper::DoesLeadingMeetCriteria(pMCParticle, fCriteria))
                    continue;
            }
            else
            {
                if (!LArMCParticleHelper::DoesPrimaryMeetCriteria(pMCParticle, fCriteria))
                    continue;
            }
        }
        selectedParticles.push_back(pMCParticle);
    }
}

void lar_content::LArMCParticleHelper::SelectReconstructableMCParticles ( const pandora::MCParticleList *  pMCParticleList, const pandora::CaloHitList *  pCaloHitList, const PrimaryParameters &  parameters, std::function< bool(const pandora::MCParticle *const)>  fCriteria, MCContributionMap &  selectedMCParticlesToHitsMap  )

static

Select target, reconstructable mc particles that match given criteria.

Parameters

pMCParticleList	the address of the list of MCParticles
pCaloHitList	the address of the list of CaloHits
parameters	validation parameters to decide when an MCParticle is considered reconstructable
fCriteria	a function which returns a bool (= shouldSelect) for a given input MCParticle
selectedMCParticlesToHitsMap	the output mapping from selected mcparticles to their hits

Definition at line 531 of file LArMCParticleHelper.cc.

{
    // Obtain map: [mc particle -> target mc particle]
    LArMCParticleHelper::MCRelationMap mcToTargetMCMap;
    parameters.m_foldBackHierarchy ? LArMCParticleHelper::GetMCPrimaryMap(pMCParticleList, mcToTargetMCMap)
                                   : LArMCParticleHelper::GetMCToSelfMap(pMCParticleList, mcToTargetMCMap);

    // Remove non-reconstructable hits, e.g. those downstream of a neutron
    // Unless selectInputHits == false
    CaloHitList selectedCaloHitList;
    LArMCParticleHelper::SelectCaloHits(pCaloHitList, mcToTargetMCMap, selectedCaloHitList, parameters.m_selectInputHits, parameters.m_maxPhotonPropagation);

    // Obtain maps: [hit -> target mc particle], [target mc particle -> list of hits]
    CaloHitToMCMap trueHitToTargetMCMap;
    MCContributionMap targetMCToTrueHitListMap;
    LArMCParticleHelper::GetMCParticleToCaloHitMatches(&selectedCaloHitList, mcToTargetMCMap, trueHitToTargetMCMap, targetMCToTrueHitListMap);

    // Obtain vector: target mc particles
    MCParticleVector targetMCVector;
    if (parameters.m_foldBackHierarchy)
    {
        LArMCParticleHelper::GetPrimaryMCParticleList(pMCParticleList, targetMCVector);
    }
    else
    {
        std::copy(pMCParticleList->begin(), pMCParticleList->end(), std::back_inserter(targetMCVector));
    }

    // Select MCParticles matching criteria
    MCParticleVector candidateTargets;
    LArMCParticleHelper::SelectParticlesMatchingCriteria(targetMCVector, fCriteria, candidateTargets, parameters, false);

    // Ensure the MCParticles have enough "good" hits to be reconstructed
    LArMCParticleHelper::SelectParticlesByHitCount(candidateTargets, targetMCToTrueHitListMap, mcToTargetMCMap, parameters, selectedMCParticlesToHitsMap);
}

void lar_content::LArMCParticleHelper::SelectReconstructableTestBeamHierarchyMCParticles ( const pandora::MCParticleList *  pMCParticleList, const pandora::CaloHitList *  pCaloHitList, const PrimaryParameters &  parameters, std::function< bool(const pandora::MCParticle *const)>  fCriteria, MCContributionMap &  selectedMCParticlesToHitsMap  )

static

Select target, reconstructable mc particles in the relevant hierarchy that match given criteria.

Parameters

pMCParticleList	the address of the list of MCParticles
pCaloHitList	the address of the list of CaloHits
parameters	validation parameters to decide when an MCParticle is considered reconstructable
fCriteria	a function which returns a bool (= shouldSelect) for a given input MCParticle
selectedMCParticlesToHitsMap	the output mapping from selected mcparticles to their hits

Definition at line 570 of file LArMCParticleHelper.cc.

{
    // Obtain map: [mc particle -> target mc particle]
    LArMCParticleHelper::MCRelationMap mcToTargetMCMap;
    parameters.m_foldBackHierarchy ? LArMCParticleHelper::GetMCLeadingMap(pMCParticleList, mcToTargetMCMap)
                                   : LArMCParticleHelper::GetMCToSelfMap(pMCParticleList, mcToTargetMCMap);

    // Remove non-reconstructable hits, e.g. those downstream of a neutron
    // Unless selectInputHits == false
    CaloHitList selectedCaloHitList;
    LArMCParticleHelper::SelectCaloHits(pCaloHitList, mcToTargetMCMap, selectedCaloHitList, parameters.m_selectInputHits, parameters.m_maxPhotonPropagation);

    // Obtain maps: [hit -> target mc particle], [target mc particle -> list of hits]
    CaloHitToMCMap trueHitToTargetMCMap;
    MCContributionMap targetMCToTrueHitListMap;
    LArMCParticleHelper::GetMCParticleToCaloHitMatches(&selectedCaloHitList, mcToTargetMCMap, trueHitToTargetMCMap, targetMCToTrueHitListMap);

    // Obtain vector: target mc particles
    MCParticleVector targetMCVector;
    if (parameters.m_foldBackHierarchy)
    {
        LArMCParticleHelper::GetLeadingMCParticleList(pMCParticleList, targetMCVector);
    }
    else
    {
        std::copy(pMCParticleList->begin(), pMCParticleList->end(), std::back_inserter(targetMCVector));
    }

    // Select MCParticles matching criteria
    MCParticleVector candidateTargets;
    LArMCParticleHelper::SelectParticlesMatchingCriteria(targetMCVector, fCriteria, candidateTargets, parameters, true);

    // Ensure the MCParticles have enough "good" hits to be reconstructed
    LArMCParticleHelper::SelectParticlesByHitCount(candidateTargets, targetMCToTrueHitListMap, mcToTargetMCMap, parameters, selectedMCParticlesToHitsMap);

    // ATTN: The parent particle must be in the hierarchy map, event if not reconstructable
    for (const MCParticle *const pMCParticle : candidateTargets)
    {
        if (!LArMCParticleHelper::IsBeamParticle(pMCParticle))
            continue;

        const MCParticle *const pParentMCParticle(LArMCParticleHelper::GetParentMCParticle(pMCParticle));
        if (selectedMCParticlesToHitsMap.find(pParentMCParticle) == selectedMCParticlesToHitsMap.end())
        {
            CaloHitList caloHitList;
            selectedMCParticlesToHitsMap.insert(MCContributionMap::value_type(pParentMCParticle, caloHitList));
        }
    }
}

bool lar_content::LArMCParticleHelper::SortByMomentum ( const pandora::MCParticle *const  pLhs, const pandora::MCParticle *const  pRhs  )

static

Sort mc particles by their momentum.

Parameters

pLhs	address of first mc particle
pRhs	address of second mc particle

Definition at line 471 of file LArMCParticleHelper.cc.

{
    // Sort by momentum (prefer higher momentum)
    const float momentumLhs(pLhs->GetMomentum().GetMagnitudeSquared());
    const float momentumRhs(pRhs->GetMomentum().GetMagnitudeSquared());

    if (std::fabs(momentumLhs - momentumRhs) > std::numeric_limits<float>::epsilon())
        return (momentumLhs > momentumRhs);

    // Sort by energy (prefer lighter particles)
    if (std::fabs(pLhs->GetEnergy() - pRhs->GetEnergy()) > std::numeric_limits<float>::epsilon())
        return (pLhs->GetEnergy() < pRhs->GetEnergy());

    // Sort by PDG code (prefer smaller numbers)
    if (pLhs->GetParticleId() != pRhs->GetParticleId())
        return (pLhs->GetParticleId() < pRhs->GetParticleId());

    // Sort by vertex position (tie-breaker)
    const float positionLhs(pLhs->GetVertex().GetMagnitudeSquared());
    const float positionRhs(pRhs->GetVertex().GetMagnitudeSquared());

    return (positionLhs < positionRhs);
}

---

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

• LArMCParticleHelper.h
• LArMCParticleHelper.cc