ShowerProfilePlugin.h

Go to the documentation of this file.

#ifndef APRIL_SHOWER_PROFILE_PLUGIN_H
#define APRIL_SHOWER_PROFILE_PLUGIN_H 1

#include "Plugins/ShowerProfilePlugin.h"

namespace april_content
{
class APRILShowerProfilePlugin : public pandora::ShowerProfilePlugin
{
public:
    APRILShowerProfilePlugin();

    void CalculateShowerStartLayer(const pandora::Cluster *const pCluster, unsigned int &showerStartLayer) const;
    void CalculateLongitudinalProfile(const pandora::Cluster *const pCluster, float &profileStart, float &profileDiscrepancy) const;
    void CalculateTransverseProfile(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, ShowerPeakList &showerPeakList) const;
    void CalculateTransverseProfile(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, ShowerPeakList &showerPeakList,
        const bool inclusiveMode) const;
    void CalculateTrackBasedTransverseProfile(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, const pandora::Track *const pMinTrack,
        const pandora::TrackVector &trackVector, ShowerPeakList &showerPeakListPhoton, ShowerPeakList &showerPeakListNonPhoton) const;

private:
    class ShowerProfileEntry
    {
    public:
        ShowerProfileEntry();

        bool                        m_isAvailable;          
        float                       m_energy;               
        pandora::CaloHitList        m_caloHitList;          
        bool                        m_potentialPeak;        
        pandora::CaloHitList        m_unusedCaloHitList;    
    };

    typedef std::pair<int, int> TwoDBin;                    
    typedef std::vector<TwoDBin > TwoDBinVector;            

    class ShowerPeakObject
    {
    public:
        ShowerPeakObject(const float energy, const int uBin, const int vBin);

        float GetPeakEnergy() const;

        int GetPeakUBin() const;

        int GetPeakVBin() const;

        TwoDBinVector               m_associatedBins;       
        bool                        m_isAvailable;          
        bool                        m_isPhotonCandidate;    

    private:
        float                       m_energy;               
        int                         m_uBin;                 
        int                         m_vBin;                 
    };

    typedef std::vector<ShowerProfileEntry> ShowerProfile;          
    typedef std::vector<ShowerProfile> TwoDShowerProfile;           
    typedef std::vector<ShowerPeakObject> ShowerPeakObjectVector;   

    void CalculateTracklessTransverseShowers(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, TwoDShowerProfile &showerProfile,
        ShowerPeakObjectVector &showerPeakObjectVector) const;

    void CalculateTrackNearbyTransverseShowers(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, const pandora::Track *const pMinTrack,
        const pandora::TrackVector &trackVector, TwoDShowerProfile &showerProfile, ShowerPeakObjectVector &showerPeakObjectVector, TwoDBinVector &trackProjectionVector) const;

    void CreateEmptyTwoDShowerProfile(TwoDShowerProfile &showerProfile) const;

    void InitialiseTransverseProfile(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, TwoDShowerProfile &showerProfile) const;

    void InitialiseTransverseProfileWithTracks(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, const pandora::Track *const pMinTrack,
        const pandora::TrackVector &trackVector, TwoDShowerProfile &showerProfile, TwoDBinVector &trackProjectionVector) const;

    void CalculateProjectionAxes(const pandora::Cluster *const pCluster, pandora::CartesianVector &innerLayerCentroid, pandora::CartesianVector &uAxis,
        pandora::CartesianVector &vAxis, const pandora::Track *const pMinTrack = NULL) const;

    void InitialiseTwoDShowerProfile(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, const pandora::CartesianVector &innerLayerCentroid,
        const pandora::CartesianVector &uAxis, const pandora::CartesianVector &vAxis, TwoDShowerProfile &showerProfile) const;

    void FindTracksProjection(const pandora::Cluster *const pCluster, const pandora::TrackVector &trackVector, const pandora::CartesianVector &innerLayerCentroid,
        const pandora::CartesianVector &uAxis, const pandora::CartesianVector &vAxis, TwoDBinVector &trackProjectionVector) const;

    float GetCellLengthScale(const pandora::Cluster *const pCluster) const;

    void MaskLowHeightRegions(TwoDShowerProfile &showerProfile) const;

    void FindRawPeaksInTwoDShowerProfile(TwoDShowerProfile &showerProfile, ShowerPeakObjectVector &showerPeakObjectVector) const;

    void AssociateUnavailableBinsToPeaks(const TwoDShowerProfile &showerProfile, ShowerPeakObjectVector &showerPeakObjectVector) const;

    void AssociateBinsToPeaks(const TwoDShowerProfile &showerProfile, ShowerPeakObjectVector &showerPeakObjectVector) const;

    void AssociateBinsToPeaks(const TwoDBinVector &twoDBinVector, ShowerPeakObjectVector &showerPeakObjectVector) const;

    void ApplyQualityCutPeakNBin(ShowerPeakObjectVector &showerPeakObjectVector, TwoDBinVector &twoDBinVector) const;

    bool PassQualityCutPeakNBin(const ShowerPeakObject &showerPeakObject) const;

    void MarkPeaksCloseToTracks(const TwoDBinVector &trackProjectionVector, ShowerPeakObjectVector &showerPeakObjectVector) const;

    void MatchPeaksInTwoSlices(const ShowerPeakObjectVector &showerPeakObjectVectorFirst, ShowerPeakObjectVector &showerPeakObjectVectorNext) const;

    void ProcessShowerProfile(TwoDShowerProfile &showerProfile, ShowerPeakObjectVector &showerPeakObjectVector) const;

    void ConvertBinsToShowerLists(const TwoDShowerProfile &showerProfile, const ShowerPeakObjectVector &showerPeakObjectVector,
        ShowerPeakList &showerPeakListPhoton, ShowerPeakList &showerPeakListNonPhoton, const bool inclusiveMode) const;

    void FindHitPositionProjection(const pandora::CartesianVector &hitPosition, const pandora::CartesianVector &innerLayerCentroid, const pandora::CartesianVector &uAxis,
        const pandora::CartesianVector &vAxis, const int nOffsetBins, const float cellLengthScale, int &uBin, int &vBin) const;

    void FindBoundaryBins(const int uBin, const int vBin, const int uEdgeLow, const int uEdgeHigh, const int vEdgeLow, const int vEdgeHigh, int &uEdgeBin, int &vEdgeBin) const;

    bool IsPeak(TwoDShowerProfile &showerProfile, const int uBin, const int vBin ) const;

    bool Check8NeighbourFull(TwoDShowerProfile &showerProfile, const int uBin, const int vBin) const;

    bool Check8NeighbourFast(TwoDShowerProfile &showerProfile, const int uBin, const int vBin) const;

    float CalculatePeakFindingMetric(const float distance, const float energy)  const;

    void CalculateBestPeakUsingMetric(ShowerPeakObjectVector &showerPeakObjectVector, const int uBin, const int vBin, ShowerPeakObject *&bestShowerPeakObject) const;

    bool HasPhotonCandidate(const ShowerPeakObjectVector &showerPeakObjectVector) const;

    static bool SortShowerPeakListByEnergy(const ShowerPeak &lhs, const ShowerPeak &rhs);

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

    float        m_showerStartMipFraction;                  
    unsigned int m_showerStartNonMipLayers;                 

    float        m_longProfileBinWidth;                     
    unsigned int m_longProfileNBins;                        
    float        m_longProfileMinCosAngle;                  
    float        m_longProfileCriticalEnergy;               
    float        m_longProfileParameter0;                   
    float        m_longProfileParameter1;                   
    float        m_longProfileMaxDifference;                

    int          m_transProfileNBins;                       
    float        m_transProfilePeakThreshold;               
    unsigned int m_transProfilePeakFindingMetric;           
    unsigned int m_transProfileMinNBinsCut;                 
    unsigned int m_transProfileTrackNearbyNSlices;          
    float        m_transProfileMinTrackToPeakCut;           
    float        m_transProfileMinDisTrackMatch ;           
};

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

inline void APRILShowerProfilePlugin::CalculateTransverseProfile(const pandora::Cluster *const pCluster, const unsigned int maxPseudoLayer, ShowerPeakList &showerPeakList) const
{
    return CalculateTransverseProfile(pCluster, maxPseudoLayer, showerPeakList, false);
}

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

inline APRILShowerProfilePlugin::ShowerProfileEntry::ShowerProfileEntry() :
    m_isAvailable(true),
    m_energy(0.f),
    m_potentialPeak(true)
{
}

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

inline APRILShowerProfilePlugin::ShowerPeakObject::ShowerPeakObject(const float energy, const int uBin, const int vBin) :
    m_isAvailable(true),
    m_isPhotonCandidate(true),
    m_energy(energy),
    m_uBin(uBin),
    m_vBin(vBin)
{
    m_associatedBins.push_back(std::make_pair(uBin,vBin));
}

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

inline float APRILShowerProfilePlugin::ShowerPeakObject::GetPeakEnergy() const
{
    return m_energy;
}

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

inline int APRILShowerProfilePlugin::ShowerPeakObject::GetPeakUBin() const
{
    return m_uBin;
}

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

inline int APRILShowerProfilePlugin::ShowerPeakObject::GetPeakVBin() const
{
    return m_vBin;
}

}

#endif