CaloHit.h

Go to the documentation of this file.

 
#ifndef PANDORA_CALO_HIT_H
#define PANDORA_CALO_HIT_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 CaloHit
{
public:
    const CartesianVector &GetPositionVector() const;
 
    float GetX0() const;
 
    const CartesianVector &GetExpectedDirection() const;
 
    const CartesianVector &GetCellNormalVector() const;
 
    CellGeometry GetCellGeometry() const;
 
    float GetCellSize0() const;
 
    float GetCellSize1() const;
 
    float GetCellThickness() const;
 
    float GetNCellRadiationLengths() const;
 
    float GetNCellInteractionLengths() const;
 
    float GetInputEnergy() const;
 
    float GetTime() const;
 
    bool IsDigital() const;
 
    HitType GetHitType() const;
 
    HitRegion GetHitRegion() const;
 
    unsigned int GetLayer() const;
 
    unsigned int GetPseudoLayer() const;
 
    bool IsInOuterSamplingLayer() const;
 
    float GetMipEquivalentEnergy() const;
 
    float GetElectromagneticEnergy() const;
 
    float GetHadronicEnergy() const;
 
    float GetCellLengthScale() const;
 
    bool IsPossibleMip() const;
 
    bool IsIsolated() const;
 
    float GetWeight() const;
 
    const MCParticleWeightMap &GetMCParticleWeightMap() const;
 
    const void *GetParentAddress() const;
 
    void GetCellCorners(CartesianPointVector &cartesianPointVector) const;
 
    bool operator< (const CaloHit &rhs) const;
 
protected:
    CaloHit(const object_creation::CaloHit::Parameters &parameters);
 
    CaloHit(const object_creation::CaloHitFragment::Parameters &parameters);
 
    virtual ~CaloHit();
 
    StatusCode AlterMetadata(const object_creation::CaloHit::Metadata &metadata);
 
    StatusCode SetPseudoLayer(const unsigned int pseudoLayer);
 
    void SetMCParticleWeightMap(const MCParticleWeightMap &mcParticleWeightMap);
 
    void RemoveMCParticles();
 
    float CalculateCellLengthScale() const;
 
    void GetRectangularCellCorners(CartesianPointVector &cartesianPointVector) const;
 
    void GetPointingCellCorners(CartesianPointVector &cartesianPointVector) const;
 
    bool IsAvailable() const;
 
    void SetAvailability(bool isAvailable);
 
    CartesianVector         m_positionVector;           
    float                   m_x0;                       
    const CartesianVector   m_expectedDirection;        
    const CartesianVector   m_cellNormalVector;         
    const CellGeometry      m_cellGeometry;             
    const float             m_cellSize0;                
    const float             m_cellSize1;                
    const float             m_cellThickness;            
    const float             m_nCellRadiationLengths;    
    const float             m_nCellInteractionLengths;  
    const float             m_time;                     
    const float             m_inputEnergy;              
    const float             m_mipEquivalentEnergy;      
    const float             m_electromagneticEnergy;    
    const float             m_hadronicEnergy;           
    const bool              m_isDigital;                
    const HitType           m_hitType;                  
    const HitRegion         m_hitRegion;                
    const unsigned int      m_layer;                    
    InputUInt               m_pseudoLayer;              
    const bool              m_isInOuterSamplingLayer;   
    float                   m_cellLengthScale;          
    bool                    m_isPossibleMip;            
    bool                    m_isIsolated;               
    bool                    m_isAvailable;              
    float                   m_weight;                   
    MCParticleWeightMap     m_mcParticleWeightMap;      
    const void             *m_pParentAddress;           
 
    friend class CaloHitMetadata;
    friend class CaloHitManager;
    friend class InputObjectManager<CaloHit>;
    friend class PandoraObjectFactory<object_creation::CaloHit::Parameters, object_creation::CaloHit::Object>;
    friend class PandoraObjectFactory<object_creation::CaloHitFragment::Parameters, object_creation::CaloHitFragment::Object>;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &CaloHit::GetPositionVector() const
{
    return m_positionVector;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetX0() const
{
    return m_x0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &CaloHit::GetExpectedDirection() const
{
    return m_expectedDirection;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const CartesianVector &CaloHit::GetCellNormalVector() const
{
    return m_cellNormalVector;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline CellGeometry CaloHit::GetCellGeometry() const
{
    return m_cellGeometry;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetCellSize0() const
{
    return m_cellSize0;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetCellSize1() const
{
    return m_cellSize1;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetCellThickness() const
{
    return m_cellThickness;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetNCellRadiationLengths() const
{
    return m_nCellRadiationLengths;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetNCellInteractionLengths() const
{
    return m_nCellInteractionLengths;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetInputEnergy() const
{
    return m_inputEnergy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetTime() const
{
    return m_time;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool CaloHit::IsDigital() const
{
    return m_isDigital;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline HitType CaloHit::GetHitType() const
{
    return m_hitType;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline HitRegion CaloHit::GetHitRegion() const
{
    return m_hitRegion;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int CaloHit::GetLayer() const
{
    return m_layer;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline unsigned int CaloHit::GetPseudoLayer() const
{
    return m_pseudoLayer.Get();
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool CaloHit::IsInOuterSamplingLayer() const
{
    return m_isInOuterSamplingLayer;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetMipEquivalentEnergy() const
{
    return m_mipEquivalentEnergy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetElectromagneticEnergy() const
{
    return m_electromagneticEnergy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetHadronicEnergy() const
{
    return m_hadronicEnergy;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetCellLengthScale() const
{
    return m_cellLengthScale;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool CaloHit::IsPossibleMip() const
{
    return m_isPossibleMip;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline float CaloHit::GetWeight() const
{
    return m_weight;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool CaloHit::IsIsolated() const
{
    return m_isIsolated;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const MCParticleWeightMap &CaloHit::GetMCParticleWeightMap() const
{
    return m_mcParticleWeightMap;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline const void *CaloHit::GetParentAddress() const
{
    return m_pParentAddress;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline bool CaloHit::IsAvailable() const
{
    return m_isAvailable;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline void CaloHit::SetAvailability(bool isAvailable)
{
    m_isAvailable = isAvailable;
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_CALO_HIT_H