Track.h

Go to the documentation of this file.

 
#ifndef PANDORA_TRACK_H
#define PANDORA_TRACK_H 1
 
#include "Pandora/ObjectCreation.h"
#include "Pandora/StatusCodes.h"
 
namespace pandora
{
 
template<typename T> class InputObjectManager;
template<typename T, typename S> class PandoraObjectFactory;
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
class Track 
{
public:
    float GetD0() const;
 
    float GetZ0() const;
 
    int GetParticleId() const; 
 
    int GetCharge() const;
 
    float GetMass() const;
 
    const CartesianVector &GetMomentumAtDca() const;
 
    float GetEnergyAtDca() const;
 
    const TrackState &GetTrackStateAtStart() const;
 
    const TrackState &GetTrackStateAtEnd() const;
 
    const TrackState &GetTrackStateAtCalorimeter() const;
 
    float GetTimeAtCalorimeter() const;
 
    bool ReachesCalorimeter() const;
 
    bool IsProjectedToEndCap() const;
 
    bool CanFormPfo() const;
 
    bool CanFormClusterlessPfo() const;
 
    bool HasAssociatedCluster() const;
 
    const Cluster *GetAssociatedCluster() const;
 
    const MCParticleWeightMap &GetMCParticleWeightMap() const;
 
    const void *GetParentAddress() const;
 
    const TrackList &GetParentList() const;
 
    const TrackList &GetSiblingList() const;
 
    const TrackList &GetDaughterList() const;
 
    bool IsAvailable() const;
 
    bool operator< (const Track &rhs) const;
 
protected:
    Track(const object_creation::Track::Parameters &parameters);
 
    virtual ~Track();
 
    void SetMCParticleWeightMap(const MCParticleWeightMap &mcParticleWeightMap);
 
    void RemoveMCParticles();
 
    StatusCode SetAssociatedCluster(const Cluster *const pCluster);
 
    StatusCode RemoveAssociatedCluster(const Cluster *const pCluster);
 
    StatusCode AddParent(const Track *const pTrack);
 
    StatusCode AddDaughter(const Track *const pTrack);
 
    StatusCode AddSibling(const Track *const pTrack);
 
    void SetAvailability(bool isAvailable);
 
    const float             m_d0;                       
    const float             m_z0;                       
    const int               m_particleId;               
    const int               m_charge;                   
    const float             m_mass;                     
    const CartesianVector   m_momentumAtDca;            
    const float             m_energyAtDca;              
    const TrackState        m_trackStateAtStart;        
    const TrackState        m_trackStateAtEnd;          
    const TrackState        m_trackStateAtCalorimeter;  
    const float             m_timeAtCalorimeter;        
    const bool              m_reachesCalorimeter;       
    const bool              m_isProjectedToEndCap;      
    const bool              m_canFormPfo;               
    const bool              m_canFormClusterlessPfo;    
    const Cluster          *m_pAssociatedCluster;       
    MCParticleWeightMap     m_mcParticleWeightMap;      
    const void             *m_pParentAddress;           
    TrackList               m_parentTrackList;          
    TrackList               m_siblingTrackList;         
    TrackList               m_daughterTrackList;        
    bool                    m_isAvailable;              
 
    friend class TrackManager;
    friend class InputObjectManager<Track>;
    friend class PandoraObjectFactory<object_creation::Track::Parameters, object_creation::Track::Object>;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Track::GetD0() const
{
    return m_d0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Track::GetZ0() const
{
    return m_z0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Track::GetParticleId() const
{
    return m_particleId;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline int Track::GetCharge() const
{
    return m_charge;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Track::GetMass() const
{
    return m_mass;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &Track::GetMomentumAtDca() const
{
    return m_momentumAtDca;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Track::GetEnergyAtDca() const
{
    return m_energyAtDca;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackState &Track::GetTrackStateAtStart() const
{
    return m_trackStateAtStart;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackState &Track::GetTrackStateAtEnd() const
{
    return m_trackStateAtEnd;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackState &Track::GetTrackStateAtCalorimeter() const
{
    return m_trackStateAtCalorimeter;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float Track::GetTimeAtCalorimeter() const
{
    return m_timeAtCalorimeter;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Track::ReachesCalorimeter() const
{
    return m_reachesCalorimeter;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Track::IsProjectedToEndCap() const
{
    return m_isProjectedToEndCap;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Track::CanFormPfo() const
{
    return m_canFormPfo;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Track::CanFormClusterlessPfo() const
{
    return m_canFormClusterlessPfo;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Track::HasAssociatedCluster() const
{
    return (nullptr != m_pAssociatedCluster);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const MCParticleWeightMap &Track::GetMCParticleWeightMap() const
{
    return m_mcParticleWeightMap;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const void *Track::GetParentAddress() const
{
    return m_pParentAddress;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackList &Track::GetParentList() const
{
    return m_parentTrackList;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackList &Track::GetSiblingList() const
{
    return m_siblingTrackList;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const TrackList &Track::GetDaughterList() const
{
    return m_daughterTrackList;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool Track::IsAvailable() const
{
    return m_isAvailable;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void Track::SetAvailability(bool isAvailable)
{
    m_isAvailable = isAvailable;
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_TRACK_H