EventValidationAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_EVENT_VALIDATION_ALGORITHM_H
#define LAR_EVENT_VALIDATION_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include "larpandoracontent/LArHelpers/LArMCParticleHelper.h"

#ifdef MONITORING
#include "PandoraMonitoringApi.h"
#endif

#include <map>

namespace lar_content
{

class EventValidationAlgorithm: public pandora::Algorithm
{
public:
    EventValidationAlgorithm();

    ~EventValidationAlgorithm();

private:
    class ValidationInfo
    {
    public:
        const LArMCParticleHelper::MCContributionMap &GetAllMCParticleToHitsMap() const;

        const LArMCParticleHelper::MCContributionMap &GetTargetMCParticleToHitsMap() const;

        const LArMCParticleHelper::PfoContributionMap &GetPfoToHitsMap() const;

        const LArMCParticleHelper::MCParticleToPfoHitSharingMap &GetMCToPfoHitSharingMap() const;

        const LArMCParticleHelper::MCParticleToPfoHitSharingMap &GetInterpretedMCToPfoHitSharingMap() const;

        void SetAllMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &allMCParticleToHitsMap);

        void SetTargetMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &targetMCParticleToHitsMap);

        void SetPfoToHitsMap(const LArMCParticleHelper::PfoContributionMap &pfoToHitsMap);

        void SetMCToPfoHitSharingMap(const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap);

        void SetInterpretedMCToPfoHitSharingMap(const LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap);

    private:
        LArMCParticleHelper::MCContributionMap              m_allMCParticleToHitsMap;               
        LArMCParticleHelper::MCContributionMap              m_targetMCParticleToHitsMap;            
        LArMCParticleHelper::PfoContributionMap             m_pfoToHitsMap;                         
        LArMCParticleHelper::MCParticleToPfoHitSharingMap   m_mcToPfoHitSharingMap;                 
        LArMCParticleHelper::MCParticleToPfoHitSharingMap   m_interpretedMCToPfoHitSharingMap;      
    };

    pandora::StatusCode Run();

    void FillValidationInfo(const pandora::MCParticleList *const pMCParticleList, const pandora::CaloHitList *const pCaloHitList,
        const pandora::PfoList *const pPfoList, ValidationInfo &validationInfo) const;

    typedef std::unordered_map<const pandora::ParticleFlowObject*, unsigned int> PfoToIdMap;

    void PrintAllMatches(const ValidationInfo &validationInfo) const;

    void PrintInterpretedMatches(const ValidationInfo &validationInfo) const;

    void WriteInterpretedMatches(const ValidationInfo &validationInfo) const;

    void ProcessOutput(const ValidationInfo &validationInfo, const bool useInterpretedMatching, const bool printToScreen, const bool fillTree) const;

    void InterpretMatching(const ValidationInfo &validationInfo, LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const;

    bool GetStrongestPfoMatch(const ValidationInfo &validationInfo, const pandora::MCParticleVector &mcPrimaryVector, pandora::PfoSet &usedPfos,
        LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const;

    void GetRemainingPfoMatches(const ValidationInfo &validationInfo, const pandora::MCParticleVector &mcPrimaryVector, const pandora::PfoSet &usedPfos,
        LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap) const;

    bool IsGoodMatch(const pandora::CaloHitList &trueHits, const pandora::CaloHitList &recoHits, const pandora::CaloHitList &sharedHits) const;

    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);

    typedef std::vector<pandora::HitType> HitTypeVector;

    std::string             m_caloHitListName;              
    std::string             m_mcParticleListName;           
    std::string             m_pfoListName;                  

    bool                    m_useTrueNeutrinosOnly;         
    bool                    m_testBeamMode;                 

    bool                    m_selectInputHits;              
    float                   m_minHitSharingFraction;        
    float                   m_maxPhotonPropagation;         

    bool                    m_printAllToScreen;             
    bool                    m_printMatchingToScreen;        

    bool                    m_writeToTree;                  

    bool                    m_useSmallPrimaries;            
    unsigned int            m_matchingMinSharedHits;        
    float                   m_matchingMinCompleteness;      
    float                   m_matchingMinPurity;            

    std::string             m_treeName;                     
    std::string             m_fileName;                     

    int                     m_fileIdentifier;               
    int                     m_eventNumber;                  
};

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

inline const LArMCParticleHelper::MCContributionMap &EventValidationAlgorithm::ValidationInfo::GetAllMCParticleToHitsMap() const
{
    return m_allMCParticleToHitsMap;
}

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

inline const LArMCParticleHelper::MCContributionMap &EventValidationAlgorithm::ValidationInfo::GetTargetMCParticleToHitsMap() const
{
    return m_targetMCParticleToHitsMap;
}

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

inline const LArMCParticleHelper::PfoContributionMap &EventValidationAlgorithm::ValidationInfo::GetPfoToHitsMap() const
{
    return m_pfoToHitsMap;
}

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

inline const LArMCParticleHelper::MCParticleToPfoHitSharingMap &EventValidationAlgorithm::ValidationInfo::GetMCToPfoHitSharingMap() const
{
    return m_mcToPfoHitSharingMap;
}

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

inline const LArMCParticleHelper::MCParticleToPfoHitSharingMap &EventValidationAlgorithm::ValidationInfo::GetInterpretedMCToPfoHitSharingMap() const
{
    return m_interpretedMCToPfoHitSharingMap;
}

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

inline void EventValidationAlgorithm::ValidationInfo::SetAllMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &allMCParticleToHitsMap)
{
    m_allMCParticleToHitsMap = allMCParticleToHitsMap;
}

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

inline void EventValidationAlgorithm::ValidationInfo::SetTargetMCParticleToHitsMap(const LArMCParticleHelper::MCContributionMap &targetMCParticleToHitsMap)
{
    m_targetMCParticleToHitsMap = targetMCParticleToHitsMap;
}

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

inline void EventValidationAlgorithm::ValidationInfo::SetPfoToHitsMap(const LArMCParticleHelper::PfoContributionMap &pfoToHitsMap)
{
    m_pfoToHitsMap = pfoToHitsMap;
}

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

inline void EventValidationAlgorithm::ValidationInfo::SetMCToPfoHitSharingMap(const LArMCParticleHelper::MCParticleToPfoHitSharingMap &mcToPfoHitSharingMap)
{
    m_mcToPfoHitSharingMap = mcToPfoHitSharingMap;
}

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

inline void EventValidationAlgorithm::ValidationInfo::SetInterpretedMCToPfoHitSharingMap(const LArMCParticleHelper::MCParticleToPfoHitSharingMap &interpretedMCToPfoHitSharingMap)
{
    m_interpretedMCToPfoHitSharingMap = interpretedMCToPfoHitSharingMap;
}

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

inline void EventValidationAlgorithm::PrintAllMatches(const ValidationInfo &validationInfo) const
{
    return this->ProcessOutput(validationInfo, false, true, false);
}

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

inline void EventValidationAlgorithm::PrintInterpretedMatches(const ValidationInfo &validationInfo) const
{
    return this->ProcessOutput(validationInfo, true, true, false);
}

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

inline void EventValidationAlgorithm::WriteInterpretedMatches(const ValidationInfo &validationInfo) const
{
    return this->ProcessOutput(validationInfo, true, false, true);
}

} // namespace lar_content

#endif // LAR_EVENT_VALIDATION_ALGORITHM_H