EventValidationBaseAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_EVENT_VALIDATION_BASE_ALGORITHM_H
#define LAR_EVENT_VALIDATION_BASE_ALGORITHM_H 1

#include "Pandora/Algorithm.h"

#include "larpandoracontent/LArHelpers/LArMCParticleHelper.h"

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

#include <map>

namespace lar_content
{

class EventValidationBaseAlgorithm : public pandora::Algorithm
{
protected:
    EventValidationBaseAlgorithm();

    ~EventValidationBaseAlgorithm();

protected:
    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; 
    };

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

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

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

    LArMCParticleHelper::PrimaryParameters m_primaryParameters; 
    int m_fileIdentifier;                                       
    int m_eventNumber;                                          

    std::string m_treeName; 

private:
    pandora::StatusCode Run();

    void PrintAllMatches(const ValidationInfo &validationInfo) const;

    void PrintInterpretedMatches(const ValidationInfo &validationInfo) const;

    void WriteInterpretedMatches(const ValidationInfo &validationInfo) const;

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

    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_fileName; 
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace lar_content

#endif // LAR_EVENT_VALIDATION_BASE_ALGORITHM_H