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