TrackShowerIdFeatureTool.h

Go to the documentation of this file.

 
#ifndef LAR_TRACK_SHOWER_ID_FEATURE_TOOLS_H
#define LAR_TRACK_SHOWER_ID_FEATURE_TOOLS_H 1
 
#include "larpandoracontent/LArHelpers/LArMvaHelper.h"
 
#include "Pandora/PandoraInternal.h"
 
namespace lar_content
{
 
typedef MvaFeatureTool<const pandora::Algorithm *const, const pandora::Cluster *const> ClusterCharacterisationFeatureTool;
typedef MvaFeatureTool<const pandora::Algorithm *const, const pandora::ParticleFlowObject *const> PfoCharacterisationFeatureTool;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class TwoDShowerFitFeatureTool : public ClusterCharacterisationFeatureTool
{
public:
    TwoDShowerFitFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    float CalculateShowerFitWidth(const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster) const;
 
    unsigned int m_slidingShowerFitWindow; 
    unsigned int m_slidingLinearFitWindow; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class TwoDLinearFitFeatureTool : public ClusterCharacterisationFeatureTool
{
public:
    TwoDLinearFitFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    void CalculateVariablesSlidingLinearFit(const pandora::Cluster *const pCluster, float &straightLineLengthLarge, float &diffWithStraigthLineMean,
        float &diffWithStraightLineSigma, float &dTdLWidth, float &maxFitGapLength, float &rmsSlidingLinearFit) const;
 
    unsigned int m_slidingLinearFitWindow;      
    unsigned int m_slidingLinearFitWindowLarge; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class TwoDVertexDistanceFeatureTool : public ClusterCharacterisationFeatureTool
{
public:
    TwoDVertexDistanceFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    float CalculateVertexDistance(const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster) const;
 
    unsigned int m_slidingLinearFitWindow; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class PfoHierarchyFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    PfoHierarchyFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ThreeDLinearFitFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    ThreeDLinearFitFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    void CalculateVariablesSlidingLinearFit(const pandora::Cluster *const pCluster, float &straightLineLengthLarge,
        float &diffWithStraigthLineMean, float &maxFitGapLength, float &rmsSlidingLinearFit) const;
 
    unsigned int m_slidingLinearFitWindow;      
    unsigned int m_slidingLinearFitWindowLarge; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ThreeDVertexDistanceFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    ThreeDVertexDistanceFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ConeChargeFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    ConeChargeFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    unsigned int m_conMinHits;
    float m_minCharge;
    float m_conFracRange;
    float m_MoliereRadius;
    float m_MoliereRadiusFrac;
 
    void CalculateChargeDistribution(const pandora::CaloHitList &caloHitList, const pandora::CartesianVector &pfoStart,
        const pandora::CartesianVector &pfoDir, float &chargeCore, float &chargeHalo, float &chargeCon);
 
    float CalculateConicalness(const pandora::CaloHitList &caloHitList, const pandora::CartesianVector &pfoStart,
        const pandora::CartesianVector &pfoDir, const float pfoLength);
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ThreeDOpeningAngleFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    ThreeDOpeningAngleFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    void Divide3DCaloHitList(const pandora::Algorithm *const pAlgorithm, const pandora::CaloHitList &threeDCaloHitList,
        pandora::CartesianPointVector &pointVectorStart, pandora::CartesianPointVector &pointVectorEnd);
 
    float OpeningAngle(const pandora::CartesianVector &principal, const pandora::CartesianVector &secondary,
        const pandora::CartesianVector &eigenValues) const;
 
    float m_hitFraction;  
    float m_defaultValue; 
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ThreeDPCAFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    ThreeDPCAFeatureTool();
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class ThreeDChargeFeatureTool : public PfoCharacterisationFeatureTool
{
public:
    ThreeDChargeFeatureTool();
 
    class VertexComparator
    {
    public:
        VertexComparator(const pandora::CartesianVector vertexPosition2D);
 
        bool operator()(const pandora::CaloHit *const left, const pandora::CaloHit *const right) const;
 
        pandora::CartesianVector m_neutrinoVertex; //The neutrino vertex used to sort
    };
 
    void Run(LArMvaHelper::MvaFeatureVector &featureVector, const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
    void Run(LArMvaHelper::MvaFeatureMap &featureMap, pandora::StringVector &featureOrder, const std::string &featureToolName,
        const pandora::Algorithm *const pAlgorithm, const pandora::ParticleFlowObject *const pInputPfo);
 
private:
    void CalculateChargeVariables(const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster, float &totalCharge,
        float &chargeSigma, float &chargeMean, float &endCharge);
 
    void OrderCaloHitsByDistanceToVertex(
        const pandora::Algorithm *const pAlgorithm, const pandora::Cluster *const pCluster, pandora::CaloHitList &caloHitList);
 
    pandora::StatusCode ReadSettings(const pandora::TiXmlHandle xmlHandle);
 
    float m_endChargeFraction; 
};
 
} // namespace lar_content
 
#endif // #ifndef LAR_TRACK_SHOWER_ID_FEATURE_TOOLS_H