pandora_srcnav/_hierarchy_validation_algorithm_8cc_source.html

#include "Pandora/AlgorithmHeaders.h"


#include "larpandoracontent/LArMonitoring/HierarchyValidationAlgorithm.h"


#include "larpandoracontent/LArHelpers/LArInteractionTypeHelper.h"

#include "larpandoracontent/LArHelpers/LArVertexHelper.h"


using namespace pandora;


namespace lar_content

{


HierarchyValidationAlgorithm::HierarchyValidationAlgorithm() :

    m_event{-1},

    m_detector{"dune_fd_hd"},

    m_writeTree{false},

    m_foldToPrimaries{false},

    m_foldDynamic{false},

    m_foldToLeadingShowers{false},

    m_validateEvent{false},

    m_validateMC{false},

    m_minPurity{0.8f},

    m_minCompleteness{0.65f}

{

}


//------------------------------------------------------------------------------------------------------------------------------------------


HierarchyValidationAlgorithm::~HierarchyValidationAlgorithm()

{

    if (m_writeTree)

    {

        PANDORA_MONITORING_API(SaveTree(this->GetPandora(), m_treename.c_str(), m_filename.c_str(), "UPDATE"));

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


StatusCode HierarchyValidationAlgorithm::Run()

{

    ++m_event;

    const CaloHitList *pCaloHitList(nullptr);

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_caloHitListName, pCaloHitList));

    const MCParticleList *pMCParticleList(nullptr);

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetCurrentList(*this, pMCParticleList));

    const PfoList *pPfoList(nullptr);

    PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, PandoraContentApi::GetList(*this, m_pfoListName, pPfoList));


    LArHierarchyHelper::FoldingParameters foldParameters;

    if (m_foldToPrimaries)

        foldParameters.m_foldToTier = true;

    else if (m_foldDynamic)

        foldParameters.m_foldDynamic = true;

    else if (m_foldToLeadingShowers)

        foldParameters.m_foldToLeadingShowers = true;

    LArHierarchyHelper::MCHierarchy mcHierarchy;

    LArHierarchyHelper::FillMCHierarchy(*pMCParticleList, *pCaloHitList, foldParameters, mcHierarchy);

    LArHierarchyHelper::RecoHierarchy recoHierarchy;

    LArHierarchyHelper::FillRecoHierarchy(*pPfoList, foldParameters, recoHierarchy);

    LArHierarchyHelper::QualityCuts quality(m_minPurity, m_minCompleteness);

    LArHierarchyHelper::MatchInfo matchInfo(mcHierarchy, recoHierarchy, quality);

    LArHierarchyHelper::MatchHierarchies(matchInfo);

    matchInfo.Print(mcHierarchy);


#ifdef MONITORING

    if (m_validateEvent)

        this->EventValidation(matchInfo);

    else if (m_validateMC)

        this->MCValidation(matchInfo);

#endif


    return STATUS_CODE_SUCCESS;

}


//------------------------------------------------------------------------------------------------------------------------------------------


#ifdef MONITORING

void HierarchyValidationAlgorithm::EventValidation(const LArHierarchyHelper::MatchInfo &matchInfo) const

{

    if (m_writeTree)

    {

        int interaction{0};

        MCParticleList rootMCParticles;

        matchInfo.GetRootMCParticles(rootMCParticles);


        const LArHierarchyHelper::RecoHierarchy &recoHierarchy{matchInfo.GetRecoHierarchy()};

        PfoList rootPfos;

        recoHierarchy.GetRootPfos(rootPfos);

        std::map<const LArHierarchyHelper::RecoHierarchy::Node *, const ParticleFlowObject *> recoNodeToRootMap;

        for (const ParticleFlowObject *const pRoot : rootPfos)

        {

            LArHierarchyHelper::RecoHierarchy::NodeVector nodes;

            recoHierarchy.GetFlattenedNodes(pRoot, nodes);

            for (const LArHierarchyHelper::RecoHierarchy::Node *pNode : nodes)

                recoNodeToRootMap[pNode] = pRoot;

        }


        std::set<const pandora::ParticleFlowObject *> matchedRecoSliceRoots;

        for (const MCParticle *const pRoot : rootMCParticles)

        {

            const LArHierarchyHelper::MCMatchesVector &matches{matchInfo.GetMatches(pRoot)};


            MCParticleList primaries;

            for (const LArHierarchyHelper::MCMatches &match : matches)

            {

                const LArHierarchyHelper::MCHierarchy::Node *pMCNode{match.GetMC()};

                if (pMCNode->GetHierarchyTier() == 1)

                {

                    const MCParticle *const pLeadingMC{pMCNode->GetLeadingMCParticle()};

                    primaries.emplace_back(pLeadingMC);

                }

            }

            primaries.sort(LArMCParticleHelper::SortByMomentum);

            const InteractionDescriptor descriptor{LArInteractionTypeHelper::GetInteractionDescriptor(primaries)};


            const int isCC{descriptor.IsCC()};

            const int isQE{descriptor.IsQE()};

            const int isResonant{descriptor.IsResonant()};

            const int isDIS{descriptor.IsDIS()};

            const int isCoherent{descriptor.IsCoherent()};

            const int isNuMu{descriptor.IsMuonNeutrino()};

            const int isNuE{descriptor.IsElectronNeutrino()};

            const int nPiZero{static_cast<int>(descriptor.GetNumPiZero())};

            const int nPiPlus{static_cast<int>(descriptor.GetNumPiPlus())};

            const int nPiMinus{static_cast<int>(descriptor.GetNumPiMinus())};

            const int nPhotons{static_cast<int>(descriptor.GetNumPhotons())};

            const int nProtons{static_cast<int>(descriptor.GetNumProtons())};


            std::set<const LArHierarchyHelper::MCHierarchy::Node *> trackNodeSet, showerNodeSet;

            int nGoodTrackMatches{0}, nGoodShowerMatches{0};

            int nGoodMatches{0}, nPoorMatches{0}, nUnmatched{0};

            int nGoodTier1Matches{0}, nTier1Nodes{0};

            int nGoodTier1TrackMatches{0}, nTier1TrackNodes{0};

            int nGoodTier1ShowerMatches{0}, nTier1ShowerNodes{0};

            int hasLeadingMuon{0}, hasLeadingElectron{0}, isLeadingLeptonCorrect{0};

            for (const LArHierarchyHelper::MCMatches &mcMatch : matches)

            {

                const LArHierarchyHelper::MCHierarchy::Node *pNode{mcMatch.GetMC()};


                for (const LArHierarchyHelper::RecoHierarchy::Node *pReco : mcMatch.GetRecoMatches())

                    matchedRecoSliceRoots.insert(recoNodeToRootMap[pReco]);


                const int nReco{static_cast<int>(mcMatch.GetRecoMatches().size())};

                const bool isQuality{mcMatch.IsQuality(matchInfo.GetQualityCuts())};

                if (nReco == 1 && isQuality)

                    ++nGoodMatches;

                else if (nReco >= 1)

                    ++nPoorMatches;

                else

                    ++nUnmatched;

                if (pNode->GetHierarchyTier() == 1)

                {

                    ++nTier1Nodes;

                    if (nReco == 1 && isQuality)

                        ++nGoodTier1Matches;

                }


                const int pdg{std::abs(pNode->GetParticleId())};

                if (pNode->IsLeadingLepton())

                {

                    if (pdg == MU_MINUS)

                        hasLeadingMuon = 1;

                    else if (pdg == E_MINUS)

                        hasLeadingElectron = 1;

                    isLeadingLeptonCorrect = nReco == 1 ? 1 : 0;

                }


                if (pdg == PHOTON || pdg == E_MINUS)

                {

                    showerNodeSet.insert(pNode);

                    if (nReco == 1 && isQuality)

                    {

                        ++nGoodShowerMatches;

                        if (pNode->GetHierarchyTier() == 1)

                            ++nGoodTier1ShowerMatches;

                    }

                    if (pNode->GetHierarchyTier() == 1)

                        ++nTier1ShowerNodes;

                }

                else

                {

                    trackNodeSet.insert(pNode);

                    if (nReco == 1 && isQuality)

                    {

                        ++nGoodTrackMatches;

                        if (pNode->GetHierarchyTier() == 1)

                            ++nGoodTier1TrackMatches;

                    }

                    if (pNode->GetHierarchyTier() == 1)

                        ++nTier1TrackNodes;

                }

            }


            const int nNodes{static_cast<int>(matchInfo.GetNMCNodes(pRoot))};

            const int nTrackNodes{static_cast<int>(trackNodeSet.size())}, nShowerNodes{static_cast<int>(showerNodeSet.size())};

            const int nRecoSlices{static_cast<int>(matchedRecoSliceRoots.size())};

            const CartesianVector &trueVertex{pRoot->GetVertex()};

            float vtxDx{std::numeric_limits<float>::max()};

            float vtxDy{std::numeric_limits<float>::max()};

            float vtxDz{std::numeric_limits<float>::max()};

            float vtxDr{std::numeric_limits<float>::max()};

            const int isFiducial{LArVertexHelper::IsInFiducialVolume(this->GetPandora(), trueVertex, m_detector)};


            for (const ParticleFlowObject *pRootPfo : matchedRecoSliceRoots)

            {

                const CartesianVector &recoVertex{LArPfoHelper::GetVertex(pRootPfo)->GetPosition()};

                const float dx{recoVertex.GetX() - trueVertex.GetX()};

                const float dy{recoVertex.GetY() - trueVertex.GetY()};

                const float dz{recoVertex.GetZ() - trueVertex.GetZ()};

                const float dr{std::sqrt(dx * dx + dy * dy + dz * dz)};

                if (dr < vtxDr)

                {

                    vtxDx = dx;

                    vtxDy = dy;

                    vtxDz = dz;

                    vtxDr = dr;

                }

            }


            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "event", m_event));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "interaction", interaction));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nRecoSlices", nRecoSlices));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isCC", isCC));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isQE", isQE));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isResonant", isResonant));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isDIS", isDIS));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isCoherent", isCoherent));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isNuMu", isNuMu));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isNuE", isNuE));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPiZero", nPiZero));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPiPlus", nPiPlus));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPiMinus", nPiMinus));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPhotons", nPhotons));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nProtons", nProtons));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isFiducial", isFiducial));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDx", vtxDx));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDy", vtxDy));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDz", vtxDz));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDr", vtxDr));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nGoodMatches", nGoodMatches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPoorMatches", nPoorMatches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nUnmatched", nUnmatched));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nNodes", nNodes));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nGoodTier1Matches", nGoodTier1Matches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nTier1Nodes", nTier1Nodes));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nGoodTrackMatches", nGoodTrackMatches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nGoodShowerMatches", nGoodShowerMatches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nTrackNodes", nTrackNodes));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nShowerNodes", nShowerNodes));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nGoodTier1TrackMatches", nGoodTier1TrackMatches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nTier1TrackNodes", nTier1TrackNodes));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nGoodTier1ShowerMatches", nGoodTier1ShowerMatches));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nTier1ShowerNodes", nTier1ShowerNodes));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "hasLeadingMuon", hasLeadingMuon));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "hasLeadingElectron", hasLeadingElectron));

            PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isLeadingLeptonCorrect", isLeadingLeptonCorrect));

            PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treename.c_str()));

            ++interaction;

        }

    }

}


//------------------------------------------------------------------------------------------------------------------------------------------


void HierarchyValidationAlgorithm::MCValidation(const LArHierarchyHelper::MatchInfo &matchInfo) const

{

    if (m_writeTree)

    {

        int interaction{0};

        MCParticleList rootMCParticles;

        matchInfo.GetRootMCParticles(rootMCParticles);

        PfoList rootPfos;

        const LArHierarchyHelper::RecoHierarchy &recoHierarchy{matchInfo.GetRecoHierarchy()};

        recoHierarchy.GetRootPfos(rootPfos);

        std::map<const LArHierarchyHelper::RecoHierarchy::Node *, const ParticleFlowObject *> recoNodeToRootMap;

        for (const ParticleFlowObject *const pRoot : rootPfos)

        {

            LArHierarchyHelper::RecoHierarchy::NodeVector nodes;

            recoHierarchy.GetFlattenedNodes(pRoot, nodes);

            for (const LArHierarchyHelper::RecoHierarchy::Node *pNode : nodes)

                recoNodeToRootMap[pNode] = pRoot;

        }


        for (const MCParticle *const pRoot : rootMCParticles)

        {

            MCParticleList primaries;

            for (const LArHierarchyHelper::MCMatches &matches : matchInfo.GetMatches(pRoot))

            {

                const LArHierarchyHelper::MCHierarchy::Node *pMCNode{matches.GetMC()};

                if (pMCNode->GetHierarchyTier() == 1)

                {

                    const MCParticle *const pLeadingMC{pMCNode->GetLeadingMCParticle()};

                    primaries.emplace_back(pLeadingMC);

                }

            }

            primaries.sort(LArMCParticleHelper::SortByMomentum);

            const InteractionDescriptor descriptor{LArInteractionTypeHelper::GetInteractionDescriptor(primaries)};


            for (const LArHierarchyHelper::MCMatches &matches : matchInfo.GetMatches(pRoot))

            {

                const LArHierarchyHelper::MCHierarchy::Node *pMCNode{matches.GetMC()};

                const int isTestBeam{pMCNode->IsTestBeamParticle() ? 1 : 0};

                const int isCosmicRay{!isTestBeam && pMCNode->IsCosmicRay() ? 1 : 0};

                const int isNeutrinoInt{!(isTestBeam || isCosmicRay) ? 1 : 0};

                const int mcId{pMCNode->GetId()};

                const int pdg{pMCNode->GetParticleId()};

                const int tier{pMCNode->GetHierarchyTier()};

                const int mcHits{static_cast<int>(pMCNode->GetCaloHits().size())};

                const int isLeadingLepton{pMCNode->IsLeadingLepton() ? 1 : 0};


                const MCParticle *const pLeadingMC{pMCNode->GetLeadingMCParticle()};

                const MCParticleList &parentList{pLeadingMC->GetParentList()};

                const int isElectron{std::abs(pLeadingMC->GetParticleId()) == E_MINUS ? 1 : 0};

                const int hasMuonParent{parentList.size() == 1 && std::abs(parentList.front()->GetParticleId()) == MU_MINUS ? 1 : 0};

                const int isMichel{isElectron && hasMuonParent && LArMCParticleHelper::IsDecay(pLeadingMC) ? 1 : 0};

                const float mcMomentum{pLeadingMC->GetMomentum().GetMagnitude()};


                const LArHierarchyHelper::RecoHierarchy::NodeVector &nodeVector{matches.GetRecoMatches()};

                const int nMatches{static_cast<int>(nodeVector.size())};

                IntVector recoSliceIdVector, recoIdVector, nRecoHitsVector, nSharedHitsVector;

                FloatVector purityVector, completenessVector;

                FloatVector purityAdcVector, completenessAdcVector;

                FloatVector purityVectorU, purityVectorV, purityVectorW, completenessVectorU, completenessVectorV, completenessVectorW;

                FloatVector purityAdcVectorU, purityAdcVectorV, purityAdcVectorW, completenessAdcVectorU, completenessAdcVectorV, completenessAdcVectorW;

                const CartesianVector &trueVertex{pLeadingMC->GetVertex()};

                float vtxDx{0.f}, vtxDy{0.f}, vtxDz{0.f}, vtxDr{0.f};


                const int isCC{descriptor.IsCC()};

                const int isQE{descriptor.IsQE()};

                const int isResonant{descriptor.IsResonant()};

                const int isDIS{descriptor.IsDIS()};

                const int isCoherent{descriptor.IsCoherent()};

                const int isNuMu{descriptor.IsMuonNeutrino()};

                const int isNuE{descriptor.IsElectronNeutrino()};

                const int nPiZero{static_cast<int>(descriptor.GetNumPiZero())};

                const int nPiPlus{static_cast<int>(descriptor.GetNumPiPlus())};

                const int nPiMinus{static_cast<int>(descriptor.GetNumPiMinus())};

                const int nPhotons{static_cast<int>(descriptor.GetNumPhotons())};

                const int nProtons{static_cast<int>(descriptor.GetNumProtons())};


                for (const LArHierarchyHelper::RecoHierarchy::Node *pRecoNode : nodeVector)

                {

                    const int sliceId{static_cast<int>(

                        std::distance(rootPfos.begin(), std::find(rootPfos.begin(), rootPfos.end(), recoNodeToRootMap[pRecoNode])))};

                    recoSliceIdVector.emplace_back(sliceId);

                    recoIdVector.emplace_back(pRecoNode->GetParticleId());

                    nRecoHitsVector.emplace_back(static_cast<int>(pRecoNode->GetCaloHits().size()));

                    nSharedHitsVector.emplace_back(static_cast<int>(matches.GetSharedHits(pRecoNode)));

                    purityVector.emplace_back(matches.GetPurity(pRecoNode));

                    completenessVector.emplace_back(matches.GetCompleteness(pRecoNode));

                    purityAdcVector.emplace_back(matches.GetPurity(pRecoNode, true));

                    completenessAdcVector.emplace_back(matches.GetCompleteness(pRecoNode, true));

                    purityVectorU.emplace_back(matches.GetPurity(pRecoNode, TPC_VIEW_U));

                    purityVectorV.emplace_back(matches.GetPurity(pRecoNode, TPC_VIEW_V));

                    purityVectorW.emplace_back(matches.GetPurity(pRecoNode, TPC_VIEW_W));

                    completenessVectorU.emplace_back(matches.GetCompleteness(pRecoNode, TPC_VIEW_U));

                    completenessVectorV.emplace_back(matches.GetCompleteness(pRecoNode, TPC_VIEW_V));

                    completenessVectorW.emplace_back(matches.GetCompleteness(pRecoNode, TPC_VIEW_W));

                    purityAdcVectorU.emplace_back(matches.GetPurity(pRecoNode, TPC_VIEW_U, true));

                    purityAdcVectorV.emplace_back(matches.GetPurity(pRecoNode, TPC_VIEW_V, true));

                    purityAdcVectorW.emplace_back(matches.GetPurity(pRecoNode, TPC_VIEW_W, true));

                    completenessAdcVectorU.emplace_back(matches.GetCompleteness(pRecoNode, TPC_VIEW_U, true));

                    completenessAdcVectorV.emplace_back(matches.GetCompleteness(pRecoNode, TPC_VIEW_V, true));

                    completenessAdcVectorW.emplace_back(matches.GetCompleteness(pRecoNode, TPC_VIEW_W, true));

                    if (nMatches > 0)

                    {

                        const CartesianVector recoVertex{LArPfoHelper::GetVertex(pRecoNode->GetLeadingPfo())->GetPosition()};

                        vtxDx = recoVertex.GetX() - trueVertex.GetX();

                        vtxDy = recoVertex.GetY() - trueVertex.GetY();

                        vtxDz = recoVertex.GetZ() - trueVertex.GetZ();

                        vtxDr = std::sqrt(vtxDx * vtxDx + vtxDy * vtxDy + vtxDz * vtxDz);

                    }

                }


                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "event", m_event));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "interaction", interaction));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "mcId", mcId));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "mcPDG", pdg));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "mcTier", tier));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "mcNHits", mcHits));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "mcMomentum", mcMomentum));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isNuInteration", isNeutrinoInt));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isCosmicRay", isCosmicRay));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isTestBeam", isTestBeam));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isLeadingLepton", isLeadingLepton));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isMichel", isMichel));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nMatches", nMatches));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "recoSliceIdVector", &recoSliceIdVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "recoIdVector", &recoIdVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nRecoHitsVector", &nRecoHitsVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nSharedHitsVector", &nSharedHitsVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityVector", &purityVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessVector", &completenessVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityAdcVector", &purityAdcVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessAdcVector", &completenessAdcVector));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityVectorU", &purityVectorU));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityVectorV", &purityVectorV));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityVectorW", &purityVectorW));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessVectorU", &completenessVectorU));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessVectorV", &completenessVectorV));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessVectorW", &completenessVectorW));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityAdcVectorU", &purityAdcVectorU));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityAdcVectorV", &purityAdcVectorV));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "purityAdcVectorW", &purityAdcVectorW));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessAdcVectorU", &completenessAdcVectorU));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessAdcVectorV", &completenessAdcVectorV));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "completenessAdcVectorW", &completenessAdcVectorW));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDx", vtxDx));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDy", vtxDy));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDz", vtxDz));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "vtxDr", vtxDr));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isCC", isCC));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isQE", isQE));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isResonant", isResonant));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isDIS", isDIS));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isCoherent", isCoherent));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isNuMu", isNuMu));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "isNuE", isNuE));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPiZero", nPiZero));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPiPlus", nPiPlus));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPiMinus", nPiMinus));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nPhotons", nPhotons));

                PANDORA_MONITORING_API(SetTreeVariable(this->GetPandora(), m_treename.c_str(), "nProtons", nProtons));

                PANDORA_MONITORING_API(FillTree(this->GetPandora(), m_treename.c_str()));

            }

            ++interaction;

        }

    }

}

#endif


//------------------------------------------------------------------------------------------------------------------------------------------


StatusCode HierarchyValidationAlgorithm::ReadSettings(const TiXmlHandle xmlHandle)

{

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "CaloHitListName", m_caloHitListName));

    if (m_caloHitListName.empty())

        m_caloHitListName = "CaloHitList2D";

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "PfoListName", m_pfoListName));

    if (m_pfoListName.empty())

        m_pfoListName = "RecreatedPfos";


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "Detector", m_detector));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ValidateEvent", m_validateEvent));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ValidateMC", m_validateMC));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "WriteTree", m_writeTree));

    if (m_writeTree)

    {

        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "FileName", m_filename));

        PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TreeName", m_treename));

        if (!(m_validateEvent || m_validateMC))

        {

            std::cout << "Error: WriteTree requested but no tree names found" << std::endl;

            return STATUS_CODE_NOT_FOUND;

        }

        else if (m_validateEvent && m_validateMC)

        {

            std::cout << "Error: Both event-level and MC-level validation requested simulataneously" << std::endl;

            return STATUS_CODE_INVALID_PARAMETER;

        }

    }


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FoldToPrimaries", m_foldToPrimaries));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FoldDynamic", m_foldDynamic));

    PANDORA_RETURN_RESULT_IF_AND_IF(

        STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "FoldToLeadingShowers", m_foldToLeadingShowers));


    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinPurity", m_minPurity));

    PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinCompleteness", m_minCompleteness));


    return STATUS_CODE_SUCCESS;

}


} // namespace lar_content

AlgorithmHeaders.h
Grouping of header files for many classes of use in particle flow algorithms.

PANDORA_MONITORING_API
#define PANDORA_MONITORING_API(command)
Definition AlgorithmHeaders.h:66

HierarchyValidationAlgorithm.h
Header file for the hierarchy validation algorithm.

LArInteractionTypeHelper.h
Header file for the interaction type helper class.

LArVertexHelper.h
Header file for the vertex helper class.

PANDORA_RETURN_RESULT_IF_AND_IF
#define PANDORA_RETURN_RESULT_IF_AND_IF(StatusCode1, StatusCode2, Operator, Command)
Definition StatusCodes.h:31

PANDORA_RETURN_RESULT_IF
#define PANDORA_RETURN_RESULT_IF(StatusCode1, Operator, Command)
Definition StatusCodes.h:19

FloatVector
std::vector< float > FloatVector
Definition Validation.h:14

PandoraContentApi::GetCurrentList
static pandora::StatusCode GetCurrentList(const pandora::Algorithm &algorithm, const T *&pT)
Get the current list.
Definition PandoraContentApi.cc:75

PandoraContentApi::GetList
static pandora::StatusCode GetList(const pandora::Algorithm &algorithm, const std::string &listName, const T *&pT)
Get a named list.
Definition PandoraContentApi.cc:116

lar_content::HierarchyValidationAlgorithm::Run
pandora::StatusCode Run()
Run the algorithm.
Definition HierarchyValidationAlgorithm.cc:47

lar_content::HierarchyValidationAlgorithm::m_pfoListName
std::string m_pfoListName
Name of input PFO list.
Definition HierarchyValidationAlgorithm.h:55

lar_content::HierarchyValidationAlgorithm::m_detector
std::string m_detector
Name of the detector.
Definition HierarchyValidationAlgorithm.h:56

lar_content::HierarchyValidationAlgorithm::m_minPurity
float m_minPurity
Minimum purity to tag a node as being of good quality.
Definition HierarchyValidationAlgorithm.h:65

lar_content::HierarchyValidationAlgorithm::m_treename
std::string m_treename
The name of the ROOT tree to write.
Definition HierarchyValidationAlgorithm.h:59

lar_content::HierarchyValidationAlgorithm::m_validateEvent
bool m_validateEvent
Whether to validate at the level of an event.
Definition HierarchyValidationAlgorithm.h:63

lar_content::HierarchyValidationAlgorithm::HierarchyValidationAlgorithm
HierarchyValidationAlgorithm()
Default constructor.
Definition HierarchyValidationAlgorithm.cc:21

lar_content::HierarchyValidationAlgorithm::m_filename
std::string m_filename
The name of the ROOT file to write.
Definition HierarchyValidationAlgorithm.h:58

lar_content::HierarchyValidationAlgorithm::m_validateMC
bool m_validateMC
Whether to validate at the level of MC nodes.
Definition HierarchyValidationAlgorithm.h:64

lar_content::HierarchyValidationAlgorithm::m_minCompleteness
float m_minCompleteness
Minimum completeness to tag a node as being of good quality.
Definition HierarchyValidationAlgorithm.h:66

lar_content::HierarchyValidationAlgorithm::m_foldToLeadingShowers
bool m_foldToLeadingShowers
Whether or not to fold the hierarchy back to leading shower particles.
Definition HierarchyValidationAlgorithm.h:62

lar_content::HierarchyValidationAlgorithm::m_foldToPrimaries
bool m_foldToPrimaries
Whether or not to fold the hierarchy back to primary particles.
Definition HierarchyValidationAlgorithm.h:60

lar_content::HierarchyValidationAlgorithm::~HierarchyValidationAlgorithm
virtual ~HierarchyValidationAlgorithm()
Definition HierarchyValidationAlgorithm.cc:37

lar_content::HierarchyValidationAlgorithm::m_writeTree
bool m_writeTree
Whether or not to output validation information to a ROOT file.
Definition HierarchyValidationAlgorithm.h:57

lar_content::HierarchyValidationAlgorithm::m_caloHitListName
std::string m_caloHitListName
Name of input calo hit list.
Definition HierarchyValidationAlgorithm.h:54

lar_content::HierarchyValidationAlgorithm::m_event
int m_event
The current event.
Definition HierarchyValidationAlgorithm.h:53

lar_content::HierarchyValidationAlgorithm::ReadSettings
pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle)
Read the algorithm settings.
Definition HierarchyValidationAlgorithm.cc:442

lar_content::HierarchyValidationAlgorithm::m_foldDynamic
bool m_foldDynamic
Whether or not to fold the hierarchy dynamically.
Definition HierarchyValidationAlgorithm.h:61

lar_content::InteractionDescriptor::IsCC
bool IsCC() const
Whether or not the interaction is CC.
Definition LArInteractionTypeHelper.h:485

lar_content::LArHierarchyHelper::FoldingParameters
FoldingParameters class.
Definition LArHierarchyHelper.h:31

lar_content::LArHierarchyHelper::FoldingParameters::m_foldToTier
bool m_foldToTier
Whether or not to apply folding based on particle tier.
Definition LArHierarchyHelper.h:56

lar_content::LArHierarchyHelper::FoldingParameters::m_foldDynamic
bool m_foldDynamic
Whether or not to use process and topological information to make folding decisions.
Definition LArHierarchyHelper.h:57

lar_content::LArHierarchyHelper::FoldingParameters::m_foldToLeadingShowers
bool m_foldToLeadingShowers
Whether or not to fold shower children to the leading shower particle.
Definition LArHierarchyHelper.h:55

lar_content::LArHierarchyHelper::MCHierarchy
MCHierarchy class.
Definition LArHierarchyHelper.h:89

lar_content::LArHierarchyHelper::MatchInfo
MatcheInfo class.
Definition LArHierarchyHelper.h:738

lar_content::LArHierarchyHelper::MatchInfo::Print
void Print(const MCHierarchy &mcHierarchy) const
Prints information about which reco nodes are matched to the MC nodes, information about hit sharing,...
Definition LArHierarchyHelper.cc:1460

lar_content::LArHierarchyHelper::MatchInfo::GetRootMCParticles
void GetRootMCParticles(pandora::MCParticleList &rootMCParticles) const
Retrieve the root MC particles of the interaction hierarchies.
Definition LArHierarchyHelper.cc:1574

lar_content::LArHierarchyHelper::MatchInfo::GetNMCNodes
unsigned int GetNMCNodes(const pandora::MCParticle *const pRoot) const
Retrieve the number of MC nodes available to match.
Definition LArHierarchyHelper.cc:1396

lar_content::LArHierarchyHelper::MatchInfo::GetMatches
const MCMatchesVector & GetMatches(const pandora::MCParticle *const pRoot) const
Retrieve the vector of matches (this will include null matches - i.e. MC nodes with no corresponding ...
Definition LArHierarchyHelper.h:1009

lar_content::LArHierarchyHelper::MatchInfo::GetRecoHierarchy
const RecoHierarchy & GetRecoHierarchy() const
Retrieve the reco hierarchy used for the matching.
Definition LArHierarchyHelper.h:1033

lar_content::LArHierarchyHelper::MatchInfo::GetQualityCuts
const QualityCuts & GetQualityCuts() const
Retrieve the quality cuts for matching.
Definition LArHierarchyHelper.h:1040

lar_content::LArHierarchyHelper::QualityCuts
QualityCuts class.
Definition LArHierarchyHelper.h:66

lar_content::LArHierarchyHelper::RecoHierarchy
RecoHierarchy class.
Definition LArHierarchyHelper.h:423

lar_content::LArHierarchyHelper::RecoHierarchy::NodeVector
std::vector< const Node * > NodeVector
Definition LArHierarchyHelper.h:426

lar_content::LArHierarchyHelper::RecoHierarchy::GetRootPfos
void GetRootPfos(pandora::PfoList &rootPfos) const
Retrieve the root particle flow objects of the interaction hierarchies.
Definition LArHierarchyHelper.cc:914

lar_content::LArHierarchyHelper::MatchHierarchies
static void MatchHierarchies(MatchInfo &matchInfo)
Finds the matches between reconstructed and MC hierarchies.
Definition LArHierarchyHelper.cc:1598

lar_content::LArHierarchyHelper::FillRecoHierarchy
static void FillRecoHierarchy(const pandora::PfoList &pfoList, const FoldingParameters &foldParameters, RecoHierarchy &hierarchy)
Fill a reconstructed hierarchy based on the specified folding criteria (see RecoHierarchy::FillHierar...
Definition LArHierarchyHelper.cc:1591

lar_content::LArHierarchyHelper::MCMatchesVector
std::vector< MCMatches > MCMatchesVector
Definition LArHierarchyHelper.h:731

lar_content::LArHierarchyHelper::FillMCHierarchy
static void FillMCHierarchy(const pandora::MCParticleList &mcParticleList, const pandora::CaloHitList &caloHitList, const FoldingParameters &foldParameters, MCHierarchy &hierarchy)
Fill an MC hierarchy based on the specified folding criteria (see MCHierarchy::FillHierarchy for deta...
Definition LArHierarchyHelper.cc:1583

lar_content::LArInteractionTypeHelper::GetInteractionDescriptor
static InteractionDescriptor GetInteractionDescriptor(const pandora::MCParticleList &mcPrimaryList)
Get the interaction descriptor of an event.
Definition LArInteractionTypeHelper.cc:416

lar_content::LArMCParticleHelper::SortByMomentum
static bool SortByMomentum(const pandora::MCParticle *const pLhs, const pandora::MCParticle *const pRhs)
Sort mc particles by their momentum.
Definition LArMCParticleHelper.cc:486

lar_content::LArMCParticleHelper::IsDecay
static bool IsDecay(const pandora::MCParticle *const pMCParticle)
Check whether or not an MC particle comes from a decay process.
Definition LArMCParticleHelper.cc:818

lar_content::LArPfoHelper::GetVertex
static const pandora::Vertex * GetVertex(const pandora::ParticleFlowObject *const pPfo)
Get the pfo vertex.
Definition LArPfoHelper.cc:471

lar_content::LArVertexHelper::IsInFiducialVolume
static bool IsInFiducialVolume(const pandora::Pandora &pandora, const pandora::CartesianVector &vertex, const std::string &detector)
Determine if a vertex is within a detector's fiducial volume. This throws a STATUS_CODE_INVALID_PARAM...
Definition LArVertexHelper.cc:67

pandora::CartesianVector
CartesianVector class.
Definition CartesianVector.h:24

pandora::CartesianVector::GetX
float GetX() const
Get the cartesian x coordinate.
Definition CartesianVector.h:259

pandora::MCParticle
MCParticle class.
Definition MCParticle.h:26

pandora::MCParticle::GetParentList
const MCParticleList & GetParentList() const
Get list of parents of mc particle.
Definition MCParticle.h:299

pandora::ParticleFlowObject
ParticleFlowObject class.
Definition ParticleFlowObject.h:26

pandora::Process::GetPandora
const Pandora & GetPandora() const
Get the associated pandora instance.
Definition Process.h:116

pandora::TiXmlHandle
Definition tinyxml.h:1646

pandora::Vertex::GetPosition
const CartesianVector & GetPosition() const
Get the vertex position.
Definition Vertex.h:103

pandora::XmlHelper::ReadValue
static StatusCode ReadValue(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, T &t)
Read a value from an xml element.
Definition XmlHelper.h:136

lar_content
Definition CheatingBeamParticleIdTool.cc:19

pandora
Definition LArContent.h:12

pandora::TPC_VIEW_V
@ TPC_VIEW_V
Definition PandoraEnumeratedTypes.h:71

pandora::TPC_VIEW_U
@ TPC_VIEW_U
Definition PandoraEnumeratedTypes.h:70

pandora::TPC_VIEW_W
@ TPC_VIEW_W
Definition PandoraEnumeratedTypes.h:72

pandora::MCParticleList
MANAGED_CONTAINER< const MCParticle * > MCParticleList
Definition PandoraInternal.h:437

pandora::IntVector
std::vector< int > IntVector
Definition LArPandoraHelper.h:28

pandora::CaloHitList
MANAGED_CONTAINER< const CaloHit * > CaloHitList
Definition PandoraInternal.h:433

pandora::StatusCode
StatusCode
The StatusCode enum.
Definition StatusCodes.h:100

pandora::PfoList
MANAGED_CONTAINER< const ParticleFlowObject * > PfoList
Definition PandoraInternal.h:439