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