lar_content::LArMonitoringHelper Class Reference

LArMonitoringHelper class. More...

#include <LArMonitoringHelper.h>

Static Public Member Functions
static unsigned int	CountHitsByType (const pandora::HitType hitType, const pandora::CaloHitList &caloHitList)
	Count the number of calo hits, in a provided list, of a specified type. More...
static void	GetOrderedMCParticleVector (const LArMCParticleHelper::MCContributionMapVector &selectedMCParticleToGoodHitsMaps, pandora::MCParticleVector &orderedMCParticleVector)
	Order input MCParticles by their number of hits. More...
static void	GetOrderedPfoVector (const LArMCParticleHelper::PfoContributionMap &pfoToReconstructable2DHitsMap, pandora::PfoVector &orderedPfoVector)
	Order input Pfos by their number of hits. More...
static void	PrintMCParticleTable (const LArMCParticleHelper::MCContributionMap &selectedMCParticleToGoodHitsMaps, const pandora::MCParticleVector &orderedMCParticleVector)
	Print details of selected MCParticles to the terminal in a table. More...
static void	PrintPfoTable (const LArMCParticleHelper::PfoContributionMap &pfoToReconstructable2DHitsMap, const pandora::PfoVector &orderedPfoVector)
	Print details of input Pfos to the terminal in a table. More...
static void	PrintMatchingTable (const pandora::PfoVector &orderedPfoVector, const pandora::MCParticleVector &orderedMCParticleVector, const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcParticleToPfoHitSharingMap, const unsigned int nMatches)
	Print the shared good hits between all Pfos and MCParticles. More...

Detailed Description

LArMonitoringHelper class.

Definition at line 21 of file LArMonitoringHelper.h.

Member Function Documentation

unsigned int lar_content::LArMonitoringHelper::CountHitsByType ( const pandora::HitType  hitType, const pandora::CaloHitList &  caloHitList  )

static

Count the number of calo hits, in a provided list, of a specified type.

Parameters

hitType	the hit type
caloHitList	the calo hit list

Returns

the number of calo hits of the specified type

Definition at line 28 of file LArMonitoringHelper.cc.

{
    unsigned int nHitsOfSpecifiedType(0);

    for (const CaloHit *const pCaloHit : caloHitList)
    {
        if (hitType == pCaloHit->GetHitType())
            ++nHitsOfSpecifiedType;
    }

    return nHitsOfSpecifiedType;
}

void lar_content::LArMonitoringHelper::GetOrderedMCParticleVector ( const LArMCParticleHelper::MCContributionMapVector &  selectedMCParticleToGoodHitsMaps, pandora::MCParticleVector &  orderedMCParticleVector  )

static

Order input MCParticles by their number of hits.

Parameters

selectedMCParticleToGoodHitsMaps	the input vector of mappings from selected reconstructable MCParticles to their good hits
orderedMCParticleVector	the output vector of ordered MCParticles

Definition at line 43 of file LArMonitoringHelper.cc.

{
    for (const LArMCParticleHelper::MCContributionMap &mcParticleToGoodHitsMap : selectedMCParticleToGoodHitsMaps)
    {
        if (mcParticleToGoodHitsMap.empty())
            continue;

        // Copy map contents to vector it can be sorted
        std::vector<LArMCParticleHelper::MCParticleCaloHitListPair> mcParticleToGoodHitsVect;
        std::copy(mcParticleToGoodHitsMap.begin(), mcParticleToGoodHitsMap.end(), std::back_inserter(mcParticleToGoodHitsVect));

        // Sort by number of hits descending
        std::sort(mcParticleToGoodHitsVect.begin(), mcParticleToGoodHitsVect.end(),
            [](const LArMCParticleHelper::MCParticleCaloHitListPair &a, const LArMCParticleHelper::MCParticleCaloHitListPair &b) -> bool {
                // Neutrinos, then beam particles, then cosmic rays
                const bool isANuFinalState(LArMCParticleHelper::IsBeamNeutrinoFinalState(a.first)),
                    isBNuFinalState(LArMCParticleHelper::IsBeamNeutrinoFinalState(b.first));

                if (isANuFinalState != isBNuFinalState)
                    return isANuFinalState;

                const bool isABeamParticle(LArMCParticleHelper::IsBeamParticle(a.first)),
                    isBBeamParticle(LArMCParticleHelper::IsBeamParticle(b.first));

                if (isABeamParticle != isBBeamParticle)
                    return isABeamParticle;

                // Then sort by numbers of true hits
                if (a.second.size() != b.second.size())
                    return (a.second.size() > b.second.size());

                // Default to normal MCParticle sorting
                return LArMCParticleHelper::SortByMomentum(a.first, b.first);
            });

        for (const LArMCParticleHelper::MCParticleCaloHitListPair &mcParticleCaloHitPair : mcParticleToGoodHitsVect)
            orderedMCParticleVector.push_back(mcParticleCaloHitPair.first);
    }

    // Check that all elements of the vector are unique
    const unsigned int nMCParticles(orderedMCParticleVector.size());
    if (std::distance(orderedMCParticleVector.begin(), std::unique(orderedMCParticleVector.begin(), orderedMCParticleVector.end())) != nMCParticles)
        throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
}

void lar_content::LArMonitoringHelper::GetOrderedPfoVector ( const LArMCParticleHelper::PfoContributionMap &  pfoToReconstructable2DHitsMap, pandora::PfoVector &  orderedPfoVector  )

static

Order input Pfos by their number of hits.

Parameters

pfoToReconstructable2DHitsMap	the input vector of mappings from Pfos to their reconstructable hits
orderedPfoVector	the output vector of ordered Pfos

Definition at line 91 of file LArMonitoringHelper.cc.

{
    // Copy map contents to vector it can be sorted
    std::vector<LArMCParticleHelper::PfoCaloHitListPair> pfoToReconstructable2DHitsVect;
    std::copy(pfoToReconstructable2DHitsMap.begin(), pfoToReconstructable2DHitsMap.end(), std::back_inserter(pfoToReconstructable2DHitsVect));

    // Sort by number of hits descending putting neutrino final states first
    std::sort(pfoToReconstructable2DHitsVect.begin(), pfoToReconstructable2DHitsVect.end(),
        [](const LArMCParticleHelper::PfoCaloHitListPair &a, const LArMCParticleHelper::PfoCaloHitListPair &b) -> bool {
            // Neutrinos before cosmic rays
            const bool isANuFinalState(LArPfoHelper::IsNeutrinoFinalState(a.first)), isBNuFinalState(LArPfoHelper::IsNeutrinoFinalState(b.first));

            if (isANuFinalState != isBNuFinalState)
                return isANuFinalState;

            if (a.second.size() != b.second.size())
                return (a.second.size() > b.second.size());

            // Default to normal pfo sorting
            return LArPfoHelper::SortByNHits(a.first, b.first);
        });

    for (const LArMCParticleHelper::PfoCaloHitListPair &pfoCaloHitPair : pfoToReconstructable2DHitsVect)
        orderedPfoVector.push_back(pfoCaloHitPair.first);

    // Check that all elements of the vector are unique
    const unsigned int nPfos(orderedPfoVector.size());
    if (std::distance(orderedPfoVector.begin(), std::unique(orderedPfoVector.begin(), orderedPfoVector.end())) != nPfos)
        throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
}

void lar_content::LArMonitoringHelper::PrintMatchingTable ( const pandora::PfoVector &  orderedPfoVector, const pandora::MCParticleVector &  orderedMCParticleVector, const LArMCParticleHelper::MCParticleToPfoHitSharingMap &  mcParticleToPfoHitSharingMap, const unsigned int  nMatches  )

static

Print the shared good hits between all Pfos and MCParticles.

Parameters

orderedPfoVector	the input vector of ordered Pfos
orderedMCParticleVector	the input vector of ordered MCParticles
mcParticleToPfoHitSharingMap	the output mapping from selected reconstructable MCParticles to Pfos and the number hits shared
nMatches	the maximum number of Pfo matches to show

Definition at line 203 of file LArMonitoringHelper.cc.

{
    if (orderedPfoVector.empty())
    {
        std::cout << "No Pfos supplied." << std::endl;
        return;
    }

    if (orderedMCParticleVector.empty())
    {
        std::cout << "No MCParticles supplied." << std::endl;
        return;
    }

    // Get the maximum number of MCParticle to Pfos matches that need to be shown
    unsigned int maxMatches(0);
    for (const auto &entry : mcParticleToPfoHitSharingMap)
        maxMatches = std::max(static_cast<unsigned int>(entry.second.size()), maxMatches);

    const bool showOthersColumn(maxMatches > nMatches);
    const unsigned int nMatchesToShow(std::min(maxMatches, nMatches));

    // Set up the table headers
    std::vector<std::string> tableHeaders({"MCParticle", ""});
    for (unsigned int i = 0; i < nMatchesToShow; ++i)
    {
        tableHeaders.push_back("");
        tableHeaders.push_back("Pfo");
        tableHeaders.push_back("nSharedHits");
    }

    if (showOthersColumn)
    {
        tableHeaders.push_back("");
        tableHeaders.push_back("");
        tableHeaders.push_back("nOtherPfos");
        tableHeaders.push_back("nSharedHits");
    }

    LArFormattingHelper::Table table(tableHeaders);

    // Make a new row for each MCParticle
    for (unsigned int mcParticleId = 0; mcParticleId < orderedMCParticleVector.size(); ++mcParticleId)
    {
        const MCParticle *const pMCParticle(orderedMCParticleVector.at(mcParticleId));
        LArMCParticleHelper::MCParticleToPfoHitSharingMap::const_iterator it = mcParticleToPfoHitSharingMap.find(pMCParticle);
        LArMCParticleHelper::PfoToSharedHitsVector pfoToSharedHitsVector;

        if (it != mcParticleToPfoHitSharingMap.end())
            pfoToSharedHitsVector = it->second;

        const LArFormattingHelper::Color mcCol(
            LArMCParticleHelper::IsBeamNeutrinoFinalState(pMCParticle)
                ? LArFormattingHelper::LIGHT_GREEN
                : (LArMCParticleHelper::IsBeamParticle(pMCParticle) ? LArFormattingHelper::LIGHT_BLUE : LArFormattingHelper::LIGHT_RED));

        // ATTN enumerate from 1 to match event validation algorithm
        table.AddElement(mcParticleId + 1, LArFormattingHelper::REGULAR, mcCol);

        // Get the matched Pfos
        unsigned int nPfosShown(0);
        unsigned int nOtherHits(0);
        for (const auto &pfoNSharedHitsPair : pfoToSharedHitsVector)
        {
            for (unsigned int pfoId = 0; pfoId < orderedPfoVector.size(); ++pfoId)
            {
                if (pfoNSharedHitsPair.first != orderedPfoVector.at(pfoId))
                    continue;

                if (nPfosShown < nMatchesToShow)
                {
                    // ATTN enumerate from 1 to match event validation algorithm
                    const LArFormattingHelper::Color pfoCol(
                        LArPfoHelper::IsNeutrinoFinalState(pfoNSharedHitsPair.first) ? LArFormattingHelper::LIGHT_GREEN : LArFormattingHelper::LIGHT_RED);
                    table.AddElement(pfoId + 1, LArFormattingHelper::REGULAR, pfoCol);
                    table.AddElement(pfoNSharedHitsPair.second.size(), LArFormattingHelper::REGULAR, pfoCol);
                    nPfosShown++;
                }
                else
                {
                    nOtherHits += pfoNSharedHitsPair.second.size();
                }
                break;
            }
        }

        // Pad the rest of the row with empty entries
        for (unsigned int i = 0; i < nMatchesToShow - nPfosShown; ++i)
        {
            table.AddElement("");
            table.AddElement("");
        }

        // Print any remaining matches
        if (!showOthersColumn)
            continue;

        if (nOtherHits != 0)
        {
            table.AddElement(pfoToSharedHitsVector.size() - nPfosShown);
            table.AddElement(nOtherHits);
        }
        else
        {
            table.AddElement("");
            table.AddElement("");
        }
    }
    table.Print();
}

void lar_content::LArMonitoringHelper::PrintMCParticleTable ( const LArMCParticleHelper::MCContributionMap &  selectedMCParticleToGoodHitsMaps, const pandora::MCParticleVector &  orderedMCParticleVector  )

static

Print details of selected MCParticles to the terminal in a table.

Parameters

selectedMCParticleToGoodHitsMap	the input mapping from selected reconstructable MCParticles to their good hits
orderedMCParticleVector	the input vector of ordered MCParticles

Definition at line 124 of file LArMonitoringHelper.cc.

{
    if (selectedMCParticleToGoodHitsMap.empty())
    {
        std::cout << "No MCParticles supplied." << std::endl;
        return;
    }

    LArFormattingHelper::Table table({"ID", "NUANCE", "TYPE", "", "E", "dist", "", "nGoodHits", "U", "V", "W"});

    unsigned int usedParticleCount(0);
    for (unsigned int id = 0; id < orderedMCParticleVector.size(); ++id)
    {
        const MCParticle *const pMCParticle(orderedMCParticleVector.at(id));

        LArMCParticleHelper::MCContributionMap::const_iterator it = selectedMCParticleToGoodHitsMap.find(pMCParticle);
        if (selectedMCParticleToGoodHitsMap.end() == it)
            continue; // ATTN MCParticles in selectedMCParticleToGoodHitsMap may be a subset of orderedMCParticleVector

        // ATTN enumerate from 1 to match event validation algorithm
        table.AddElement(id + 1);
        table.AddElement(LArMCParticleHelper::GetNuanceCode(pMCParticle));
        table.AddElement(PdgTable::GetParticleName(pMCParticle->GetParticleId()));

        table.AddElement(pMCParticle->GetEnergy());
        table.AddElement((pMCParticle->GetEndpoint() - pMCParticle->GetVertex()).GetMagnitude());

        table.AddElement(it->second.size());
        table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, it->second));
        table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, it->second));
        table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, it->second));

        usedParticleCount++;
    }

    // Check every MCParticle in selectedMCParticleToGoodHitsMap has been printed
    if (usedParticleCount != selectedMCParticleToGoodHitsMap.size())
        throw StatusCodeException(STATUS_CODE_NOT_FOUND);

    table.Print();
}

void lar_content::LArMonitoringHelper::PrintPfoTable ( const LArMCParticleHelper::PfoContributionMap &  pfoToReconstructable2DHitsMap, const pandora::PfoVector &  orderedPfoVector  )

static

Print details of input Pfos to the terminal in a table.

Parameters

pfoToReconstructable2DHitsMap	the input vector of mappings from Pfos to their reconstructable hits
orderedPfoVector	the input vector of ordered Pfos

Definition at line 169 of file LArMonitoringHelper.cc.

{
    if (pfoToReconstructable2DHitsMap.empty())
    {
        std::cout << "No Pfos supplied." << std::endl;
        return;
    }

    LArFormattingHelper::Table table({"ID", "PID", "Is Nu FS", "", "nGoodHits", "U", "V", "W"});

    for (unsigned int id = 0; id < orderedPfoVector.size(); ++id)
    {
        const ParticleFlowObject *const pPfo(orderedPfoVector.at(id));

        LArMCParticleHelper::PfoContributionMap::const_iterator it = pfoToReconstructable2DHitsMap.find(pPfo);
        if (pfoToReconstructable2DHitsMap.end() == it)
            throw StatusCodeException(STATUS_CODE_NOT_FOUND);

        // ATTN enumerate from 1 to match event validation algorithm
        table.AddElement(id + 1);
        table.AddElement(pPfo->GetParticleId());
        table.AddElement(LArPfoHelper::IsNeutrinoFinalState(pPfo));

        table.AddElement(it->second.size());
        table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_U, it->second));
        table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_V, it->second));
        table.AddElement(LArMonitoringHelper::CountHitsByType(TPC_VIEW_W, it->second));
    }

    table.Print();
}

---

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

• larpandoracontent/larpandoracontent/LArHelpers/LArMonitoringHelper.h
• larpandoracontent/larpandoracontent/LArHelpers/LArMonitoringHelper.cc