BdtBeamParticleIdTool.h

Go to the documentation of this file.

#ifndef LAR_BDT_BEAM_PARTICLE_ID_TOOL_H
#define LAR_BDT_BEAM_PARTICLE_ID_TOOL_H 1

#include "larpandoracontent/LArControlFlow/MasterAlgorithm.h"

#include "larpandoracontent/LArHelpers/LArMvaHelper.h"

#include "larpandoracontent/LArObjects/LArAdaBoostDecisionTree.h"

namespace lar_content
{

class BdtBeamParticleIdTool : public SliceIdBaseTool
{
public:
    BdtBeamParticleIdTool();

    BdtBeamParticleIdTool(const BdtBeamParticleIdTool &rhs) = default;

    BdtBeamParticleIdTool &operator=(const BdtBeamParticleIdTool &rhs) = default;

    ~BdtBeamParticleIdTool() = default;

    void SelectOutputPfos(const pandora::Algorithm *const pAlgorithm, const SliceHypotheses &beamSliceHypotheses, const SliceHypotheses &crSliceHypotheses, pandora::PfoList &selectedPfos);

private:
    class Plane
    {
    public:
        Plane(const pandora::CartesianVector &normal, const pandora::CartesianVector &point);

        pandora::CartesianVector GetLineIntersection(const pandora::CartesianVector &point, const pandora::CartesianVector &direction) const;

    private:
        pandora::CartesianVector      m_unitNormal;                         
        pandora::CartesianVector      m_point;                              
        double                        m_d;                                  
    };

    typedef std::vector<Plane> PlaneVector;

    class SliceFeatureParameters
    {
    public:
        SliceFeatureParameters();

       void Initialize(const float larTPCMinX, const float larTPCMaxX, const float larTPCMinY, const float larTPCMaxY, const float larTPCMinZ, const float larTPCMaxZ);

       void SetBeamLArTPCIntersection(const pandora::CartesianVector &beamLArTPCIntersection);

       void SetBeamDirection(const pandora::CartesianVector &beamDirection);

       void SetSelectedFraction(const float selectedFraction);

       void SetNSelectedHits(const unsigned int nSelectedHits);

       void SetContainmentLimit(const float containmentLimit);

       float GetLArTPCMinX() const;

       float GetLArTPCMaxX() const;

       float GetLArTPCMinY() const;

       float GetLArTPCMaxY() const;

       float GetLArTPCMinZ() const;

       float GetLArTPCMaxZ() const;

       const PlaneVector &GetPlanes() const;

       const pandora::CartesianVector &GetBeamLArTPCIntersection() const;

       const pandora::CartesianVector &GetBeamDirection() const;

       float GetSelectedFraction() const;

       unsigned int GetNSelectedHits() const;

       float GetContainmentLimit() const;

    private:
        float                       m_larTPCMinX;             
        float                       m_larTPCMaxX;             
        float                       m_larTPCMinY;             
        float                       m_larTPCMaxY;             
        float                       m_larTPCMinZ;             
        float                       m_larTPCMaxZ;             
        PlaneVector                 m_larTPCPlanes;           
        pandora::CartesianVector    m_beamLArTPCIntersection; 
        pandora::CartesianVector    m_beamDirection;          
        float                       m_selectedFraction;       
        unsigned int                m_nSelectedHits;          
        float                       m_containmentLimit;       
    };

    class SliceFeatures
    {
    public:
         SliceFeatures(const pandora::PfoList &nuPfos, const pandora::PfoList &crPfos, const SliceFeatureParameters &sliceFeatureParameters);

        SliceFeatures(const SliceFeatures &rhs) = default;

        SliceFeatures &operator=(const SliceFeatures &rhs) = default;

        ~SliceFeatures() = default;

        bool IsFeatureVectorAvailable() const;

        void FillFeatureVector(LArMvaHelper::MvaFeatureVector &featureVector) const;

        float GetAdaBoostDecisionTreeScore(const AdaBoostDecisionTree &adaBoostDecisionTree) const;

    private:
        void GetLeadingCaloHits(const pandora::CaloHitList &inputCaloHitList, pandora::CaloHitList &outputCaloHitList,
            double &closestHitToFaceDistance) const;

        void GetLArTPCIntercepts(const pandora::CartesianVector &a0, const pandora::CartesianVector &majorAxis,
            pandora::CartesianVector &interceptOne, pandora::CartesianVector &interceptTwo) const;

        bool IsContained(const pandora::CartesianVector &spacePoint, const float limit) const;

        bool                            m_isAvailable;               
        const SliceFeatureParameters    m_sliceFeatureParameters;    
        LArMvaHelper::MvaFeatureVector  m_featureVector;             
    };

    typedef std::vector<SliceFeatures> SliceFeaturesVector;
    typedef std::pair<unsigned int, float> UintFloatPair;
    typedef std::unordered_map<const pandora::MCParticle*, int> MCParticleToIntMap;

    pandora::StatusCode Initialize();

    void GetSliceFeatures(const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses, SliceFeaturesVector &sliceFeaturesVector) const;

    void SelectAllPfos(const pandora::Algorithm *const pAlgorithm, const SliceHypotheses &hypotheses, pandora::PfoList &selectedPfos) const;

    void SelectPfos(const pandora::PfoList &pfos, pandora::PfoList &selectedPfos) const;

    void GetBestMCSliceIndices(const pandora::Algorithm *const pAlgorithm, const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses, pandora::IntVector &bestSliceIndices) const;

    void PopulateMCParticleToHitsMap(MCParticleToIntMap &mcParticleToIntMap, const pandora::CaloHitList &caloHitList) const;

    void Collect2DHits(const pandora::PfoList &pfos, pandora::CaloHitList &caloHitList, const pandora::CaloHitSet &reconstructableCaloHitSet) const;

    bool PassesQualityCuts(const float purity, const float completeness) const;

    void SelectPfosByAdaBDTScore(const pandora::Algorithm *const pAlgorithm, const SliceHypotheses &nuSliceHypotheses, const SliceHypotheses &crSliceHypotheses, const SliceFeaturesVector &sliceFeaturesVector, pandora::PfoList &selectedPfos) const;

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

    // Training
    bool                            m_useTrainingMode;                      
    std::string                     m_trainingOutputFile;                   
    std::string                     m_caloHitListName;                      
    std::string                     m_mcParticleListName;                   
    float                           m_minPurity;                            
    float                           m_minCompleteness;                      

    // Classification
    AdaBoostDecisionTree            m_adaBoostDecisionTree;                 
    std::string                     m_filePathEnvironmentVariable;          
    unsigned int                    m_maxNeutrinos;                         
    float                           m_minAdaBDTScore;                       
    SliceFeatureParameters          m_sliceFeatureParameters;               
};

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

inline void BdtBeamParticleIdTool::SliceFeatureParameters::SetBeamLArTPCIntersection(const pandora::CartesianVector &beamLArTPCIntersection)
{
    m_beamLArTPCIntersection = beamLArTPCIntersection;
}

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

inline void BdtBeamParticleIdTool::SliceFeatureParameters::SetBeamDirection(const pandora::CartesianVector &beamDirection)
{
    m_beamDirection = beamDirection;
}

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

inline void BdtBeamParticleIdTool::SliceFeatureParameters::SetSelectedFraction(const float selectedFraction)
{
    m_selectedFraction = selectedFraction;
}

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

inline void BdtBeamParticleIdTool::SliceFeatureParameters::SetNSelectedHits(const unsigned int nSelectedHits)
{
    m_nSelectedHits = nSelectedHits;
}

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

inline void BdtBeamParticleIdTool::SliceFeatureParameters::SetContainmentLimit(const float containmentLimit)
{
    m_containmentLimit = containmentLimit;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetLArTPCMinX() const
{
    return m_larTPCMinX;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetLArTPCMaxX() const
{
    return m_larTPCMaxX;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetLArTPCMinY() const
{
    return m_larTPCMinY;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetLArTPCMaxY() const
{
    return m_larTPCMaxY;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetLArTPCMinZ() const
{
    return m_larTPCMinZ;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetLArTPCMaxZ() const
{
    return m_larTPCMaxZ;
}

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

inline const BdtBeamParticleIdTool::PlaneVector &BdtBeamParticleIdTool::SliceFeatureParameters::GetPlanes() const
{
    return m_larTPCPlanes;
}

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

inline const pandora::CartesianVector &BdtBeamParticleIdTool::SliceFeatureParameters::GetBeamLArTPCIntersection() const
{
    return m_beamLArTPCIntersection;
}

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

inline const pandora::CartesianVector &BdtBeamParticleIdTool::SliceFeatureParameters::GetBeamDirection() const
{
    return m_beamDirection;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetSelectedFraction() const
{
    return m_selectedFraction;
}

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

inline unsigned int BdtBeamParticleIdTool::SliceFeatureParameters::GetNSelectedHits() const
{
    return m_nSelectedHits;
}

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

inline float BdtBeamParticleIdTool::SliceFeatureParameters::GetContainmentLimit() const
{
    return m_containmentLimit;
}

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

inline bool BdtBeamParticleIdTool::SliceFeatures::IsFeatureVectorAvailable() const
{
    return m_isAvailable;
}

} // namespace lar_content

#endif // #ifndef LAR_BDT_BEAM_PARTICLE_ID_TOOL_H