DLLaterTierHierarchyTool.h

Go to the documentation of this file.

#ifndef LAR_DL_LATER_TIER_HIERARCHY_TOOL_H
#define LAR_DL_LATER_TIER_HIERARCHY_TOOL_H 1

#include "Pandora/PandoraInternal.h"

#include "larpandoradlcontent/LArHelpers/LArDLHelper.h"
#include "larpandoradlcontent/LArThreeDReco/LArEventBuilding/DLBaseHierarchyTool.h"
#include "larpandoradlcontent/LArThreeDReco/LArEventBuilding/LArHierarchyPfo.h"

namespace lar_dl_content
{

class DLLaterTierHierarchyTool : public DLBaseHierarchyTool
{
public:
    struct DLLaterTierNetworkParams // all floats because they'll be normalised
    {
        float m_parentTrackScore = -999.f;          
        float m_childTrackScore = -999.f;           
        float m_parentNSpacepoints = -999.f;        
        float m_childNSpacepoints = -999.f;         
        float m_separation3D = -999.f;              
        float m_parentNuVertexSep = -999.f;         
        float m_childNuVertexSep = -999.f;          
        float m_parentEndRegionNHits = -999.f;      
        float m_parentEndRegionNParticles = -999.f; 
        float m_parentEndRegionRToWall = -999.f;    
        float m_vertexSeparation = -999.f;          
        float m_doesChildConnect = -999.f;          
        pandora::CartesianVector m_connectionPoint = pandora::CartesianVector(-999.f, -999.f, -999.f); 
        pandora::CartesianVector m_connectionDirection = pandora::CartesianVector(-999.f, -999.f, -999.f); 
        float m_overshootStartDCA = -999.f;     
        float m_overshootStartL = -999.f;       
        float m_overshootEndDCA = -999.f;       
        float m_overshootEndL = -999.f;         
        float m_childCPDCA = -999.f;            
        float m_childCPExtrapDistance = -999.f; 
        float m_childCPLRatio = -999.f; 
        float m_parentCPNUpstreamHits = -999.f; 
        float m_parentCPNDownstreamHits = -999.f; 
        float m_parentCPNHitRatio = -999.f; 
        float m_parentCPEigenvalueRatio = -999.f; 
        float m_parentCPOpeningAngle = -999.f; 
        float m_parentIsPOIClosestToNu = -999.f; 
        float m_childIsPOIClosestToNu = -999.f;  

        void AddCommonParamsToInput(int &insertIndex, LArDLHelper::TorchInput &modelInput) const;

        void AddOrientationParamsToInput(int &insertIndex, LArDLHelper::TorchInput &modelInput) const;
    };

    pandora::StatusCode Run(const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pNeutrinoPfo,
        const HierarchyPfo &parentHierarchyPfo, const HierarchyPfo &childHierarchyPfo,
        std::vector<DLLaterTierNetworkParams> &networkParamVector, float &laterTierScore);

    DLLaterTierHierarchyTool();

private:
    struct NormalisationLimits
    {
        float m_trackScoreMin = -1.f;                
        float m_trackScoreMax = 1.f;                 
        float m_nSpacepointsMin = 0.f;               
        float m_nSpacepointsMax = 2000.f;            
        float m_separation3DMin = -50.f;             
        float m_separation3DMax = 700.f;             
        float m_nuVertexSepMin = -100.f;             
        float m_nuVertexSepMax = 750.f;              
        float m_parentEndRegionNHitsMin = -10.f;     
        float m_parentEndRegionNHitsMax = 80.f;      
        float m_parentEndRegionNParticlesMin = -1.f; 
        float m_parentEndRegionNParticlesMax = 5.f;  
        float m_parentEndRegionRToWallMin = -10.f;   
        float m_parentEndRegionRToWallMax = 400.f;   
        float m_vertexSepMin = -50.f;                
        float m_vertexSepMax = 700.f;                
        float m_doesChildConnectMin = -1.f;          
        float m_doesChildConnectMax = 1.f;           
        float m_overshootDCAMin = -700.f;            
        float m_overshootDCAMax = 700.f;             
        float m_overshootLMin = -100.f;              
        float m_overshootLMax = 700.f;               
        float m_childCPDCAMin = -5.f;                
        float m_childCPDCAMax = 50.f;                
        float m_childCPExtrapDistanceMin = -500.f;   
        float m_childCPExtrapDistanceMax = 500.f;    
        float m_childCPLRatioMin = -1.f;             
        float m_childCPLRatioMax = 1.f;              
        float m_parentCPNHitsMin = -10.f;            
        float m_parentCPNHitsMax = 100.f;            
        float m_parentCPNHitRatioMin = -5.f;         
        float m_parentCPNHitRatioMax = 30.f;         
        float m_parentCPEigenvalueRatioMin = -5.f;   
        float m_parentCPEigenvalueRatioMax = 50.f;   
        float m_parentCPOpeningAngleMin = -10.f;     
        float m_parentCPOpeningAngleMax = 180.f;     
    };

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

    bool IsShowerVertexUpstream(const HierarchyPfo &parentHierarchyPfo, const HierarchyPfo &childHierarchyPfo) const;

    pandora::StatusCode CalculateNetworkVariables(const pandora::Algorithm *const pAlgorithm, const HierarchyPfo &parentHierarchyPfo,
        const HierarchyPfo &childHierarchyPfo, const pandora::ParticleFlowObject *const pNeutrinoPfo, const bool useUpstreamForParent,
        const bool useUpstreamForChild, DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void SetCommonParams(const std::pair<float, float> &trackScoreParams, const std::pair<float, float> &nSpacepointsParams,
        const float separation3D, DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void SetVertexParams(const pandora::CartesianVector &nuVertex, const pandora::CartesianVector &parentStartPos,
        const pandora::CartesianVector &parentEndPos, const pandora::CartesianVector &childStartPos,
        DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void SetEndRegionParams(const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pParentPfo,
        const pandora::CartesianVector &parentEndPos, DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void SetEndRegionRToWall(const pandora::CartesianVector &parentEndPos, DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void SetConnectionParams(const HierarchyPfo &parentHierarchyPfo, const pandora::CartesianVector &parentStartPos,
        const ExtremalPoint &childStart, DLLaterTierNetworkParams &laterTierNetworkParams) const;

    std::pair<pandora::CartesianVector, bool> ExtrapolateChildToParent(
        const pandora::CartesianVector &parentPosition, const ExtremalPoint &childStart) const;

    bool DoesConnect(const pandora::CartesianVector &boundary1, const pandora::CartesianVector &boundary2, const pandora::CartesianVector &testPoint) const;

    void SetOvershootParams(const ExtremalPoint &parentStart, const ExtremalPoint &parentEnd, const ExtremalPoint &childStart,
        DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void SetParentConnectionPointVars(const HierarchyPfo &parentHierarchyPfo, DLLaterTierNetworkParams &laterTierNetworkParams) const;

    void NormaliseNetworkParams(DLLaterTierNetworkParams &laterTierNetworkParams) const;

    float ClassifyTrackTrack(const DLLaterTierNetworkParams &edgeParamsUpUp, const DLLaterTierNetworkParams &edgeParamsUpDown,
        const DLLaterTierNetworkParams &edgeParamsDownUp, const DLLaterTierNetworkParams &edgeParamsDownDown);

    pandora::FloatVector ClassifyTrackTrackEdge(const DLLaterTierNetworkParams &edgeParams, const DLLaterTierNetworkParams &otherEdgeParams1,
        const DLLaterTierNetworkParams &otherEdgeParams2, const DLLaterTierNetworkParams &otherEdgeParams3);

    float ClassifyTrackShower(const DLLaterTierNetworkParams &edgeParamsUp, const DLLaterTierNetworkParams &edgeParamsDown);

    pandora::FloatVector ClassifyTrackShowerEdge(const DLLaterTierNetworkParams &edgeParams, const DLLaterTierNetworkParams &otherEdgeParams);

    // For model
    std::string m_trackTrackBranchModelName;              
    std::string m_trackTrackClassifierModelName;          
    std::string m_trackShowerBranchModelName;             
    std::string m_trackShowerClassifierModelName;         
    LArDLHelper::TorchModel m_trackTrackBranchModel;      
    LArDLHelper::TorchModel m_trackTrackClassifierModel;  
    LArDLHelper::TorchModel m_trackShowerBranchModel;     
    LArDLHelper::TorchModel m_trackShowerClassifierModel; 
    // For tool
    bool m_trainingMode;        
    float m_trajectoryStepSize; 
    float m_connectionBuffer;   
    float m_searchRegion;       
    // For normalisation
    bool m_normalise;                 
    NormalisationLimits m_normLimits; 
};

} // namespace lar_dl_content

#endif // #ifndef LAR_DL_LATER_TIER_HIERARCHY_TOOL_H