Cluster.h

Go to the documentation of this file.

 
#ifndef PANDORA_CLUSTER_H
#define PANDORA_CLUSTER_H 1
 
#include "Helpers/ClusterFitHelper.h"
 
#include "Objects/OrderedCaloHitList.h"
 
#include "Pandora/ObjectCreation.h"
#include "Pandora/StatusCodes.h"
 
namespace pandora
{
 
class Pandora;
template<typename T> class AlgorithmObjectManager;
template<typename T, typename S> class PandoraObjectFactory;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class Cluster
{
public:
    const OrderedCaloHitList &GetOrderedCaloHitList() const;
 
    const CaloHitList &GetIsolatedCaloHitList() const;
 
    unsigned int GetNCaloHits() const;
 
    unsigned int GetNIsolatedCaloHits() const;
 
    unsigned int GetNPossibleMipHits() const;
 
    float GetMipFraction() const;
 
    unsigned int GetNHitsInOuterLayer() const;
 
    float GetElectromagneticEnergy() const;
 
    float GetHadronicEnergy() const;
 
    float GetIsolatedElectromagneticEnergy() const;
 
    float GetIsolatedHadronicEnergy() const;
 
    int GetParticleId() const;
 
    bool IsTrackSeeded() const;
 
    const Track *GetTrackSeed() const;
 
    unsigned int GetInnerPseudoLayer() const;
 
    unsigned int GetOuterPseudoLayer() const;
 
    const CartesianVector GetCentroid(const unsigned int pseudoLayer) const;
 
    const CartesianVector &GetInitialDirection() const;
 
    const ClusterFitResult &GetFitToAllHitsResult() const;
 
    HitType GetInnerLayerHitType() const;
 
    HitType GetOuterLayerHitType() const;
 
    const TrackList &GetAssociatedTrackList() const;
 
    bool IsAvailable() const;
 
    float GetCorrectedElectromagneticEnergy(const Pandora &pandora) const;
 
    float GetCorrectedHadronicEnergy(const Pandora &pandora) const;
 
    float GetTrackComparisonEnergy(const Pandora &pandora) const;
 
    bool PassPhotonId(const Pandora &pandora) const;
 
    unsigned int GetShowerStartLayer(const Pandora &pandora) const;
 
    float GetShowerProfileStart(const Pandora &pandora) const;
 
    float GetShowerProfileDiscrepancy(const Pandora &pandora) const;
 
    void GetClusterSpanX(float &xmin, float &xmax) const;
 
    void GetClusterSpanZ(const float xmin, const float xmax, float &zmin, float &zmax) const;
 
protected:
    Cluster(const object_creation::Cluster::Parameters &parameters);
 
    virtual ~Cluster();
 
    StatusCode AlterMetadata(const object_creation::Cluster::Metadata &metadata);
 
    StatusCode AddCaloHit(const CaloHit *const pCaloHit);
 
    StatusCode RemoveCaloHit(const CaloHit *const pCaloHit);
 
    StatusCode AddIsolatedCaloHit(const CaloHit *const pCaloHit);
 
    StatusCode RemoveIsolatedCaloHit(const CaloHit *const pCaloHit);
 
    void UpdateFitToAllHitsCache() const;
 
    void UpdateInitialDirectionCache() const;
 
    void UpdateLayerHitTypeCache(const unsigned int pseudoLayer, InputHitType &layerHitType) const;
 
    void UpdateEnergyCorrectionsCache(const Pandora &pandora) const;
 
    void UpdatePhotonIdCache(const Pandora &pandora) const;
 
    void UpdateShowerLayerCache(const Pandora &pandora) const;
 
    void UpdateShowerProfileCache(const Pandora &pandora) const;
 
    StatusCode ResetProperties();
 
    void ResetOutdatedProperties();
 
    StatusCode AddHitsFromSecondCluster(const Cluster *const pCluster);
 
    StatusCode AddTrackAssociation(const Track *const pTrack);
 
    StatusCode RemoveTrackAssociation(const Track *const pTrack);
 
    void RemoveTrackSeed();
 
    void SetAvailability(bool isAvailable);
 
    class SimplePoint
    {
    public:
        double                  m_xyzPositionSums[3];           
        unsigned int            m_nHits;                        
    };
 
    typedef std::map<unsigned int, SimplePoint> PointByPseudoLayerMap;
    typedef std::map<HitType, float> HitTypeToEnergyMap;        
 
    OrderedCaloHitList          m_orderedCaloHitList;           
    CaloHitList                 m_isolatedCaloHitList;          
    unsigned int                m_nCaloHits;                    
    unsigned int                m_nPossibleMipHits;             
    unsigned int                m_nCaloHitsInOuterLayer;        
    double                      m_electromagneticEnergy;        
    double                      m_hadronicEnergy;               
    double                      m_isolatedElectromagneticEnergy;
    double                      m_isolatedHadronicEnergy;       
    int                         m_particleId;                   
    const Track                *m_pTrackSeed;                   
    PointByPseudoLayerMap       m_sumXYZByPseudoLayer;          
    InputUInt                   m_innerPseudoLayer;             
    InputUInt                   m_outerPseudoLayer;             
 
    mutable CartesianVector     m_initialDirection;             
    mutable bool                m_isDirectionUpToDate;          
    mutable ClusterFitResult    m_fitToAllHitsResult;           
    mutable bool                m_isFitUpToDate;                
    mutable InputFloat          m_correctedElectromagneticEnergy;
    mutable InputFloat          m_correctedHadronicEnergy;      
    mutable InputFloat          m_trackComparisonEnergy;        
    mutable InputBool           m_passPhotonId;                 
    mutable InputUInt           m_showerStartLayer;             
    mutable InputFloat          m_showerProfileStart;           
    mutable InputFloat          m_showerProfileDiscrepancy;     
    mutable InputHitType        m_innerLayerHitType;            
    mutable InputHitType        m_outerLayerHitType;            
    mutable InputFloat          m_xMin;                         
    mutable InputFloat          m_xMax;                         
 
    TrackList                   m_associatedTrackList;          
    bool                        m_isAvailable;                  
 
    friend class ClusterManager;
    friend class AlgorithmObjectManager<Cluster>;
    friend class PandoraObjectFactory<object_creation::Cluster::Parameters, object_creation::Cluster::Object>;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const OrderedCaloHitList &Cluster::GetOrderedCaloHitList() const
{
    return m_orderedCaloHitList;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CaloHitList &Cluster::GetIsolatedCaloHitList() const
{
    return m_isolatedCaloHitList;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int Cluster::GetNCaloHits() const
{
    return m_nCaloHits;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int Cluster::GetNIsolatedCaloHits() const
{
    return m_isolatedCaloHitList.size();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int Cluster::GetNPossibleMipHits() const
{
    return m_nPossibleMipHits;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Cluster::GetMipFraction() const
{
    return ((0 != m_nCaloHits) ? static_cast<float> (m_nPossibleMipHits) / static_cast<float> (m_nCaloHits) : 0);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int Cluster::GetNHitsInOuterLayer() const
{
    return m_nCaloHitsInOuterLayer;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Cluster::GetElectromagneticEnergy() const
{
    return static_cast<float>(m_electromagneticEnergy);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Cluster::GetHadronicEnergy() const
{
    return static_cast<float>(m_hadronicEnergy);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Cluster::GetIsolatedElectromagneticEnergy() const
{
    return static_cast<float>(m_isolatedElectromagneticEnergy);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Cluster::GetIsolatedHadronicEnergy() const
{
    return static_cast<float>(m_isolatedHadronicEnergy);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Cluster::GetParticleId() const
{
    return m_particleId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Cluster::IsTrackSeeded() const
{
    return (nullptr != m_pTrackSeed);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int Cluster::GetInnerPseudoLayer() const
{
    return m_innerPseudoLayer.Get();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int Cluster::GetOuterPseudoLayer() const
{
    return m_outerPseudoLayer.Get();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackList &Cluster::GetAssociatedTrackList() const
{
    return m_associatedTrackList;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Cluster::IsAvailable() const
{
    return m_isAvailable;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void Cluster::SetAvailability(bool isAvailable)
{
    m_isAvailable = isAvailable;
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_CLUSTER_H