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 *, 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::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::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	IsBeamNeutrinoFinalState (const pandora::MCParticle *const pMCParticle)
	Returns true if passed a primary neutrino final state MCParticle. More...
static bool	IsBeamParticle (const pandora::MCParticle *const pMCParticle)
	Returns true if passed a primary 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	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 const pandora::MCParticle *	GetPrimaryMCParticle (const pandora::MCParticle *const pMCParticle)
	Get the primary parent mc particle. 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 const pandora::MCParticle *	GetParentMCParticle (const pandora::MCParticle *const pMCParticle)
	Get the parent mc particle. 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 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 &mcToPrimaryMCMap, 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 primary, reconstructable mc particles that match given criteria. More...
static void	GetPfoToReconstructable2DHitsMap (const pandora::PfoList &pfoList, const MCContributionMap &selectedMCParticleToHitsMap, PfoContributionMap &pfoToReconstructable2DHitsMap)
	Get mapping from Pfo 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)
	Get mapping from Pfo 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 &mcToPrimaryMCMap, 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 Private Member Functions
static void	CollectReconstructable2DHits (const pandora::ParticleFlowObject *const pPfo, const MCContributionMapVector &selectedMCParticleToHitsMaps, pandora::CaloHitList &reconstructableCaloHitList2D)
	For a given Pfo, 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 &mcToPrimaryMCMap, 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)
	Select mc particles matching given criteria from an input list. More...
static void	SelectParticlesByHitCount (const pandora::MCParticleVector &candidateTargets, const MCContributionMap &mcToTrueHitListMap, const MCRelationMap &mcToPrimaryMCMap, const PrimaryParameters &parameters, MCContributionMap &selectedMCParticlesToHitsMap)
	Filter an input vector of MCParticles to ensure they have sufficient good hits to be reconstructable. 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...
static pandora::CaloHitList	GetSharedHits (const pandora::CaloHitList &hitListA, const pandora::CaloHitList &hitListB)
	Get the hits in the intersection of two hit lists. 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 31 of file LArMCParticleHelper.h.

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

Definition at line 32 of file LArMCParticleHelper.h.

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

Definition at line 34 of file LArMCParticleHelper.h.

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

Definition at line 35 of file LArMCParticleHelper.h.

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

Definition at line 40 of file LArMCParticleHelper.h.

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

Definition at line 47 of file LArMCParticleHelper.h.

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

Definition at line 43 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 29 of file LArMCParticleHelper.h.

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

Definition at line 38 of file LArMCParticleHelper.h.

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

Definition at line 41 of file LArMCParticleHelper.h.

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

Definition at line 37 of file LArMCParticleHelper.h.

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

Definition at line 46 of file LArMCParticleHelper.h.

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

Definition at line 44 of file LArMCParticleHelper.h.

Member Function Documentation

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

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

Definition at line 390 of file LArMCParticleHelper.cc.

References lar_content::LArPfoHelper::GetAllDownstreamPfos(), lar_content::LArPfoHelper::GetCaloHits(), and lar_content::LArPfoHelper::GetIsolatedCaloHits().

Referenced by SelectReconstructableMCParticles().

{
    // Collect all 2D calo hits in pfo hierarchy
    PfoList pfoList;
    LArPfoHelper::GetAllDownstreamPfos(pPfo, pfoList);

    CaloHitList caloHitList2D;
    LArPfoHelper::GetCaloHits(pfoList, TPC_VIEW_U, caloHitList2D);
    LArPfoHelper::GetCaloHits(pfoList, TPC_VIEW_V, caloHitList2D);
    LArPfoHelper::GetCaloHits(pfoList, TPC_VIEW_W, caloHitList2D);
    LArPfoHelper::GetIsolatedCaloHits(pfoList, TPC_VIEW_U, caloHitList2D); // TODO check isolated usage throughout
    LArPfoHelper::GetIsolatedCaloHits(pfoList, TPC_VIEW_V, caloHitList2D);
    LArPfoHelper::GetIsolatedCaloHits(pfoList, TPC_VIEW_W, caloHitList2D);

    // Filter for only reconstructable hits
    for (const CaloHit *const pCaloHit : caloHitList2D)
    {
        bool isTargetHit(false);
        for (const MCContributionMap &mcParticleToHitsMap : selectedMCParticleToHitsMaps)
        {
            // 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);
    }
}

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 210 of file LArMCParticleHelper.cc.

References lar_content::LArPfoHelper::GetTwoDClusterList().

Referenced by lar_content::CheatingNeutrinoCreationAlgorithm::GetMCParticleToDaughterPfoMap(), lar_content::SvmPfoCharacterisationAlgorithm::IsClearTrack(), and lar_content::CheatingNeutrinoDaughterVerticesAlgorithm::ProcessDaughterPfo().

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

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

static

Match calo hits to their parent particles.

Parameters

pCaloHitList	the input list of calo hits
mcToPrimaryMCMap	input mapping between mc particles and their primaries
hitToPrimaryMCMap	output mapping between calo hits and their main MC particle (primary MC particle if mcToPrimaryMCMap provided)
mcToTrueHitListMap	output mapping between MC particles and their associated hits

Definition at line 245 of file LArMCParticleHelper.cc.

Referenced by lar_content::MCParticleMonitoringAlgorithm::PrintPrimaryMCParticles(), and SelectReconstructableMCParticles().

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

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

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

                pPrimaryParticle = mcIter->second;
            }

            mcToTrueHitListMap[pPrimaryParticle].push_back(pCaloHit);
            hitToMCMap[pCaloHit] = pPrimaryParticle;
        }
        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 195 of file LArMCParticleHelper.cc.

References GetPrimaryMCParticle().

Referenced by lar_content::NeutrinoIdTool::GetBestMCSliceIndex(), lar_content::BdtBeamParticleIdTool::GetBestMCSliceIndices(), lar_content::CheatingNeutrinoCreationAlgorithm::GetMCParticleToDaughterPfoMap(), lar_content::CheatingClusterCreationAlgorithm::GetMCParticleToHitListMap(), lar_content::CheatingNeutrinoDaughterVerticesAlgorithm::GetMCPrimaryMap(), lar_content::CheatingPfoCreationAlgorithm::Run(), and SelectReconstructableMCParticles().

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

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

static

Get the nuance code of an MCParticle.

Definition at line 68 of file LArMCParticleHelper.cc.

References lar_content::LArMCParticle::GetNuanceCode().

Referenced by lar_content::BdtBeamParticleIdTool::GetBestMCSliceIndices(), lar_content::NeutrinoIdTool::GetNuanceCode(), IsBeamParticle(), IsCosmicRay(), IsNeutrino(), and lar_content::EventValidationAlgorithm::ProcessOutput().

{
    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 134 of file LArMCParticleHelper.cc.

Referenced by lar_content::NeutrinoIdTool::CountNeutrinoInducedHits(), IsBeamNeutrinoFinalState(), lar_content::BdtBeamParticleIdTool::PopulateMCParticleToHitsMap(), and lar_content::EventValidationAlgorithm::ProcessOutput().

{
    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 332 of file LArMCParticleHelper.cc.

References GetSharedHits(), SortByMomentum(), and lar_content::LArPfoHelper::SortByNHits().

Referenced by lar_content::EventValidationAlgorithm::FillValidationInfo(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), and lar_content::PfoValidationAlgorithm::Run().

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

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

Referenced by lar_content::EventValidationAlgorithm::FillValidationInfo(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::PfoValidationAlgorithm::Run(), and SelectReconstructableMCParticles().

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

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

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 164 of file LArMCParticleHelper.cc.

References IsVisible().

Referenced by GetMCPrimaryMap(), and IsPrimary().

{
    // 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 151 of file LArMCParticleHelper.cc.

References IsPrimary(), and SortByMomentum().

Referenced by SelectReconstructableMCParticles().

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

staticprivate

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 594 of file LArMCParticleHelper.cc.

Referenced by GetPfoMCParticleHitSharingMaps().

{
    CaloHitList sharedHits;

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

    return sharedHits;
}

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 121 of file LArMCParticleHelper.cc.

References IsNeutrino(), and SortByMomentum().

Referenced by lar_content::SvmVertexSelectionAlgorithm::GetBestVertex(), lar_content::CheatingNeutrinoCreationAlgorithm::GetMCNeutrinoVector(), lar_content::NeutrinoIdTool::GetNuanceCode(), lar_content::EventWritingAlgorithm::PassNeutrinoVertexFilter(), and lar_content::EventWritingAlgorithm::PassNuanceCodeFilter().

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

    std::sort(trueNeutrinos.begin(), trueNeutrinos.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 44 of file LArMCParticleHelper.cc.

References GetParentMCParticle(), IsNeutrino(), and IsPrimary().

Referenced by lar_content::EventValidationAlgorithm::FillValidationInfo(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::SvmVertexSelectionAlgorithm::GetInteractionType(), IsCosmicRay(), lar_content::EventWritingAlgorithm::PassMCParticleFilter(), lar_content::EventValidationAlgorithm::ProcessOutput(), lar_content::PfoValidationAlgorithm::Run(), and lar_content::MCParticleMonitoringAlgorithm::Run().

{
    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 52 of file LArMCParticleHelper.cc.

References GetNuanceCode(), and IsPrimary().

Referenced by lar_content::EventValidationAlgorithm::FillValidationInfo(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::EventWritingAlgorithm::PassMCParticleFilter(), lar_content::EventValidationAlgorithm::ProcessOutput(), lar_content::PfoValidationAlgorithm::Run(), lar_content::MCParticleMonitoringAlgorithm::Run(), and lar_content::CheatingBeamParticleIdTool::SelectOutputPfos().

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

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

static

Return true if passed a primary cosmic ray MCParticle.

Definition at line 60 of file LArMCParticleHelper.cc.

References GetNuanceCode(), IsBeamNeutrinoFinalState(), and IsPrimary().

Referenced by lar_content::EventValidationAlgorithm::FillValidationInfo(), lar_content::CheatingCosmicRayTaggingTool::FindAmbiguousPfos(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::EventWritingAlgorithm::PassMCParticleFilter(), lar_content::EventValidationAlgorithm::ProcessOutput(), lar_content::PfoValidationAlgorithm::Run(), and lar_content::MCParticleMonitoringAlgorithm::Run().

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

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 80 of file LArMCParticleHelper.cc.

References GetNuanceCode().

Referenced by lar_content::NeutrinoIdTool::CountNeutrinoInducedHits(), lar_content::CheatingNeutrinoCreationAlgorithm::GetMCNeutrinoVector(), GetTrueNeutrinos(), IsBeamNeutrinoFinalState(), lar_content::CheatingVertexCreationAlgorithm::Run(), and lar_content::CheatingCosmicRayIdentificationAlg::Run().

{
    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::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 92 of file LArMCParticleHelper.cc.

References GetPrimaryMCParticle().

Referenced by GetPrimaryMCParticleList(), IsBeamNeutrinoFinalState(), IsBeamParticle(), and IsCosmicRay().

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

    return false;
}

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 105 of file LArMCParticleHelper.cc.

Referenced by GetPrimaryMCParticle().

{
    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 568 of file LArMCParticleHelper.cc.

Referenced by SelectCaloHits().

{
    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 &  mcToPrimaryMCMap, 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
mcToPrimaryMCMap	the mc particle to primary 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 430 of file LArMCParticleHelper.cc.

References PassMCParticleChecks().

Referenced by lar_content::NeutrinoIdTool::GetBestMCSliceIndex(), lar_content::BdtBeamParticleIdTool::GetBestMCSliceIndices(), and SelectReconstructableMCParticles().

{
    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 = mcToPrimaryMCMap.find(pHitParticle);

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

            const MCParticle *const pPrimaryParticle = mcIter->second;

            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 &  mcToPrimaryMCMap, 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)
mcToPrimaryMCMap	the mc particle to primary 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 463 of file LArMCParticleHelper.cc.

References f, and weight.

Referenced by SelectParticlesByHitCount().

{
    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 primaryWeightMap;

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

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

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

        const MCParticle *pBestPrimaryParticle(nullptr);
        float bestPrimaryWeight(0.f), primaryWeightSum(0.f);

        for (const MCParticle *const pPrimaryMCParticle : mcPrimaryVector)
        {
            const float primaryWeight(primaryWeightMap.at(pPrimaryMCParticle));
            primaryWeightSum += primaryWeight;

            if (primaryWeight > bestPrimaryWeight)
            {
                bestPrimaryWeight = primaryWeight;
                pBestPrimaryParticle = pPrimaryMCParticle;
            }
        }

        if (!pBestPrimaryParticle || (primaryWeightSum < std::numeric_limits<float>::epsilon()) || ((bestPrimaryWeight / primaryWeightSum) < minHitSharingFraction))
            continue;

        selectedGoodCaloHitList.push_back(pCaloHit);
    }
}

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

staticprivate

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

Parameters

candidateTargets	candidate recontructable MCParticles
mcToTrueHitListMap	mapping from candidates reconstructable MCParticles to their true hits
mcToPrimaryMCMap	the mc particle to primary 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 529 of file LArMCParticleHelper.cc.

References lar_content::LArMonitoringHelper::CountHitsByType(), lar_content::LArMCParticleHelper::PrimaryParameters::m_minHitsForGoodView, lar_content::LArMCParticleHelper::PrimaryParameters::m_minHitSharingFraction, lar_content::LArMCParticleHelper::PrimaryParameters::m_minPrimaryGoodHits, lar_content::LArMCParticleHelper::PrimaryParameters::m_minPrimaryGoodViews, lar_content::LArMCParticleHelper::PrimaryParameters::m_selectInputHits, and SelectGoodCaloHits().

Referenced by SelectReconstructableMCParticles().

{
    // 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, mcToPrimaryMCMap, 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  )

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

Definition at line 517 of file LArMCParticleHelper.cc.

Referenced by SelectReconstructableMCParticles().

{
    for (const MCParticle *const pMCParticle : inputMCParticles)
    {
        if (fCriteria(pMCParticle))
            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 primary, 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 279 of file LArMCParticleHelper.cc.

References CollectReconstructable2DHits(), GetMCParticleToCaloHitMatches(), GetMCPrimaryMap(), GetPfoToReconstructable2DHitsMap(), GetPrimaryMCParticleList(), lar_content::LArMCParticleHelper::PrimaryParameters::m_maxPhotonPropagation, lar_content::LArMCParticleHelper::PrimaryParameters::m_selectInputHits, SelectCaloHits(), SelectParticlesByHitCount(), and SelectParticlesMatchingCriteria().

Referenced by lar_content::EventValidationAlgorithm::FillValidationInfo(), lar_content::CosmicRayTaggingMonitoringTool::FindAmbiguousPfos(), lar_content::SvmVertexSelectionAlgorithm::GetInteractionType(), lar_content::EventWritingAlgorithm::PassMCParticleFilter(), lar_content::PfoValidationAlgorithm::Run(), and lar_content::MCParticleMonitoringAlgorithm::Run().

{
    // Obtain map: [mc particle -> primary mc particle]
    LArMCParticleHelper::MCRelationMap mcToPrimaryMCMap;
    LArMCParticleHelper::GetMCPrimaryMap(pMCParticleList, mcToPrimaryMCMap);

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

    // Obtain maps: [hit -> primary mc particle], [primary mc particle -> list of hits]
    CaloHitToMCMap hitToPrimaryMCMap;
    MCContributionMap mcToTrueHitListMap;
    LArMCParticleHelper::GetMCParticleToCaloHitMatches(&selectedCaloHitList, mcToPrimaryMCMap, hitToPrimaryMCMap, mcToTrueHitListMap);

    // Obtain vector: primary mc particles
    MCParticleVector mcPrimaryVector;
    LArMCParticleHelper::GetPrimaryMCParticleList(pMCParticleList, mcPrimaryVector);

    // Select MCParticles matching criteria
    MCParticleVector candidateTargets;
    LArMCParticleHelper::SelectParticlesMatchingCriteria(mcPrimaryVector, fCriteria, candidateTargets);

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

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 219 of file LArMCParticleHelper.cc.

Referenced by lar_content::CheatingClusterCreationAlgorithm::CreateClusters(), lar_content::CheatingPfoCreationAlgorithm::CreatePfos(), lar_content::SvmVertexSelectionAlgorithm::GetInteractionType(), GetPfoMCParticleHitSharingMaps(), GetPrimaryMCParticleList(), GetTrueNeutrinos(), lar_content::EventWritingAlgorithm::PassMCParticleFilter(), and lar_content::MasterAlgorithm::Reset().

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

• larpandoracontent/v03_13_02/source/larpandoracontent/LArHelpers/LArMCParticleHelper.h
• larpandoracontent/v03_13_02/source/larpandoracontent/LArHelpers/LArMCParticleHelper.cc