ThreeDHitCreationAlgorithm.h

Go to the documentation of this file.

#ifndef LAR_THREE_D_HIT_CREATION_ALGORITHM_H
#define LAR_THREE_D_HIT_CREATION_ALGORITHM_H 1

#include "Pandora/Algorithm.h"
#include "Pandora/AlgorithmTool.h"

#include <vector>

namespace lar_content
{

class HitCreationBaseTool;
class ThreeDSlidingFitResult;

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

class ThreeDHitCreationAlgorithm : public pandora::Algorithm
{
public:
    class TrajectorySample
    {
    public:
        TrajectorySample(const pandora::CartesianVector &position, const pandora::HitType hitType, const double sigma);

        const pandora::CartesianVector &GetPosition() const;

        pandora::HitType GetHitType() const;

        double GetSigma() const;

    private:
        pandora::CartesianVector    m_position;             
        pandora::HitType            m_hitType;              
        double                      m_sigma;                
    };

    typedef std::vector<TrajectorySample> TrajectorySampleVector;

    class ProtoHit
    {
    public:
        ProtoHit(const pandora::CaloHit *const pParentCaloHit2D);

        const pandora::CaloHit *GetParentCaloHit2D() const;

        bool IsPositionSet() const;

        const pandora::CartesianVector &GetPosition3D() const;

        double GetChi2() const;

        unsigned int GetNTrajectorySamples() const;

        const TrajectorySample &GetFirstTrajectorySample() const;

        const TrajectorySample &GetLastTrajectorySample() const;

        void SetPosition3D(const pandora::CartesianVector &position3D, const double chi2);

        void AddTrajectorySample(const TrajectorySample &trajectorySample);

    private:
        const pandora::CaloHit     *m_pParentCaloHit2D;         
        bool                        m_isPositionSet;            
        pandora::CartesianVector    m_position3D;               
        double                      m_chi2;                     
        TrajectorySampleVector      m_trajectorySampleVector;   
    };

    typedef std::vector<ProtoHit> ProtoHitVector;

    ThreeDHitCreationAlgorithm();

    void FilterCaloHitsByType(const pandora::CaloHitVector &inputCaloHitVector, const pandora::HitType hitType,
        pandora::CaloHitVector &outputCaloHitVector) const;

private:
    pandora::StatusCode Run();

    void SeparateTwoDHits(const pandora::ParticleFlowObject *const pPfo, const ProtoHitVector &protoHitVector,
        pandora::CaloHitVector &remainingHitVector) const;

    void IterativeTreatment(ProtoHitVector &protoHitVector) const;

    void ExtractResults(const ProtoHitVector &protoHitVector, double &chi2, pandora::CartesianPointVector &pointVector) const;

    double GetChi2WrtFit(const ThreeDSlidingFitResult &slidingFitResult, const ProtoHitVector &protoHitVector) const;

    double GetHitMovementChi2(const ProtoHitVector &protoHitVector) const;

    void RefineHitPositions(const ThreeDSlidingFitResult &slidingFitResult, ProtoHitVector &protoHitVector) const;

    void CreateThreeDHits(const ProtoHitVector &protoHitVector, pandora::CaloHitList &newThreeDHits) const;

    void CreateThreeDHit(const ProtoHit &protoHit, const pandora::CaloHit *&pCaloHit3D) const;

    bool CheckThreeDHit(const ProtoHit &protoHit) const;

    void AddThreeDHitsToPfo(const pandora::ParticleFlowObject *const pPfo, const pandora::CaloHitList &caloHitList) const;

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

    typedef std::vector<HitCreationBaseTool*> HitCreationToolVector;
    HitCreationToolVector   m_algorithmToolVector;      

    std::string             m_inputPfoListName;         
    std::string             m_outputCaloHitListName;    
    std::string             m_outputClusterListName;    

    bool                    m_iterateTrackHits;         
    bool                    m_iterateShowerHits;        
    unsigned int            m_slidingFitHalfWindow;     
    unsigned int            m_nHitRefinementIterations; 
    double                  m_sigma3DFitMultiplier;     
    double                  m_iterationMaxChi2Ratio;    
};

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

inline ThreeDHitCreationAlgorithm::TrajectorySample::TrajectorySample(const pandora::CartesianVector &position, const pandora::HitType hitType, const double sigma) :
    m_position(position),
    m_hitType(hitType),
    m_sigma(sigma)
{
}

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

inline const pandora::CartesianVector &ThreeDHitCreationAlgorithm::TrajectorySample::GetPosition() const
{
    return m_position;
}

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

inline pandora::HitType ThreeDHitCreationAlgorithm::TrajectorySample::GetHitType() const
{
    return m_hitType;
}

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

inline double ThreeDHitCreationAlgorithm::TrajectorySample::GetSigma() const
{
    return m_sigma;
}

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

inline ThreeDHitCreationAlgorithm::ProtoHit::ProtoHit(const pandora::CaloHit *const pParentCaloHit2D) :
    m_pParentCaloHit2D(pParentCaloHit2D),
    m_isPositionSet(false),
    m_position3D(0.f, 0.f, 0.f),
    m_chi2(std::numeric_limits<double>::max())
{
}

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

inline const pandora::CaloHit *ThreeDHitCreationAlgorithm::ProtoHit::GetParentCaloHit2D() const
{
    return m_pParentCaloHit2D;
}

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

inline bool ThreeDHitCreationAlgorithm::ProtoHit::IsPositionSet() const
{
    return m_isPositionSet;
}

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

inline unsigned int ThreeDHitCreationAlgorithm::ProtoHit::GetNTrajectorySamples() const
{
    return m_trajectorySampleVector.size();
}

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

inline void ThreeDHitCreationAlgorithm::ProtoHit::SetPosition3D(const pandora::CartesianVector &position3D, const double chi2)
{
    m_position3D = position3D;
    m_chi2 = chi2;
    m_isPositionSet = true;
}

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

inline void ThreeDHitCreationAlgorithm::ProtoHit::AddTrajectorySample(const TrajectorySample &trajectorySample)
{
    m_trajectorySampleVector.push_back(trajectorySample);
}

} // namespace lar_content

#endif // #ifndef LAR_THREE_D_HIT_CREATION_ALGORITHM_H